xoopit-cloudquery 0.1.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 nb.io
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,73 @@
+cloudquery
+==========
+
+Client for Xoopit's cloudquery API
+
+Install
+-------
+
+    sudo gem install xoopit-cloudquery-ruby
+
+Simple contacts application example
+-----------------------------------
+
+    > require 'cloudquery'
+    => true
+    > include Cloudquery
+    => Object
+    > secret = Client.get_secret(<account_name>, <password>)
+    => "your secret appears here"
+    > c = Client.new(:account => '<account_name>', :secret => secret)
+    => #<Cloudquery::Client:0x10b1b24 @secure=true, @secret="your secret appears here", @account="<account_name>", @document_id_method=nil>
+    > c.add_indexes('superheroes')
+    => {"result"=>["kMzzzybpqpY"], "size"=>1, "STATUS"=>200}
+    > c.add_schema(File.open('simple.contact.xml'))
+    => {"result"=>["ubKme0EX3H2ud7VhBU7qngk3........."], "size"=>1, "STATUS"=>201}
+    > doc = {
+        'simple.contact.name' => 'Steve Rogers',
+        'simple.contact.email' => ['steve.rogers@example.com','captain.america@marvel.com'],
+        'simple.contact.telephone' => ['555-555-5555','123-456-6789'],
+        'simple.contact.address' => ['Lower East Side, NY NY'],
+        'simple.contact.birthday' => Date.parse('July 4, 1917'),
+        'simple.contact.note' => 'Captain America!',
+      }
+    => {"simple.contact.birthday"=>#<Date: 4842827/2,0,2299161>, "simple.contact.address"=>["Lower East Side, NY NY"], "simple.contact.telephone"=>["555-555-5555", "123-456-6789"], "simple.contact.note"=>"Captain America!", "simple.contact.email"=>["steve.rogers@example.com", "captain.america@marvel.com"], "simple.contact.name"=>"Steve Rogers"}
+    > c.add_documents('superheroes', doc, 'simple.contact')
+    => {"result"=>["nDLCNLPo3oHtxANzG4YBn5kMzzzybpqpY"], "size"=>1, "STATUS"=>201}
+    > docs = [
+      {
+        'simple.contact.name' => 'Clark Kent',
+        'simple.contact.email' => ['clark.kent@example.com','superman@dc.com'], 
+        'simple.contact.telephone' => ['555-123-1234','555-456-6789'],
+        'simple.contact.address' => ['344 Clinton St., Apt. #3B, Metropolis', 'The Fortess of Solitude, North Pole'],
+        'simple.contact.birthday' => Date.parse('June 18, 1938'),
+        'simple.contact.note' => 'Superhuman strength, speed, stamina, durability, senses, intelligence, regeneration, and longevity; super breath, heat vision, x-ray vision and flight. Member of the justice league.'
+      },
+      {
+        'simple.contact.name' => 'Bruce Wayne',
+        'simple.contact.email' => ['bruce.wayne@example.com','batman@dc.com'],
+        'simple.contact.telephone' => ['555-123-6666','555-456-6666'],
+        'simple.contact.address' => ['1007 Mountain Drive, Gotham', 'The Batcave, Gotham'],
+        'simple.contact.birthday' => Date.parse('February 19, 1939'),
+        'simple.contact.note' => 'Sidekick is Robin. Has problems with the Joker. Member of   e justice league.'
+      }
+    ]
+    > c.add_documents('superheroes', docs, 'simple.contact')
+    => {"result"=>["lQgByVSvJk1skHtKpMYX40kMzzzybpqpY", "weJF4uDPJrlvrETTJQNibFkMzzzybpqpY"], "size"=>2, "STATUS"=>201}
+    > c.count_documents('superheroes', '*', 'simple.contact')
+    => {"result"=>3, "matches"=>3, "STATUS"=>200}
+    > c.get_documents('superheroes', '*', {:fields => 'simple.contact.name'}, 'simple.contact')
+    => {"result"=>[{"simple.contact.name"=>"Steve Rogers"}, {"simple.contact.name"=>"Clark Kent"}, {"simple.contact.name"=>"Bruce Wayne"}], "matches"=>3, "size"=>3, "STATUS"=>200}
+    > c.get_documents('superheroes', 'name:Steve', {:fields => 'simple.contact.name'}, 'simple.contact')
+    => {"result"=>[{"simple.contact.name"=>"Steve Rogers"}], "matches"=>1, "size"=>1, "STATUS"=>200}
+    > c.get_documents('superheroes', ':@:justice', {:fields => 'simple.contact.name'}, 'simple.contact')
+    => {"result"=>[{"simple.contact.name"=>"Clark Kent"}, {"simple.contact.name"=>"Bruce Wayne"}], "matches"=>2, "size"=>2, "STATUS"=>200}
+    > c.modify_documents('superheroes', 'name:steve', {'simple.contact.note' => 'His name is STEVE!'}, 'simple.contact')
+    => {"result"=>["nDLCNLPo3oHtxANzG4YBn5kMzzzybpqpY"], "matches"=>1, "size"=>1, "STATUS"=>200}
+    > c.delete_documents('superheroes', 'name:steve', 'simple.contact') => {"result"=>["nDLCNLPo3oHtxANzG4YBn5kMzzzybpqpY"], "matches"=>2, "size"=>1, "STATUS"=>200}
+
+
+Copyright
+---------
+
+Copyright (c) 2009 nb.io, LLC and Xoopit, Inc. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,75 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "cloudquery"
+    gem.summary = "Client for Xoopit's cloudquery API"
+    gem.email = "us@nb.io"
+    gem.homepage = "http://github.com/nbio/cloudquery"
+    gem.description = "Client for Xoopit's cloudquery API"
+    gem.authors = ["Cameron Walters", "nb.io"]
+    gem.files =  FileList["[A-Z]*", "{lib,spec}/**/*"] 
+    # gem.rubyforge_project = "cloudquery"
+  
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "cloudquery #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+# begin
+#   require 'rake/contrib/sshpublisher'
+#   namespace :rubyforge do
+#     
+#     desc "Release gem and RDoc documentation to RubyForge"
+#     task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
+#     
+#     namespace :release do
+#       desc "Publish RDoc to RubyForge."
+#       task :docs => [:rdoc] do
+#         config = YAML.load(
+#             File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+#         )
+# 
+#         host = "#{config['username']}@rubyforge.org"
+#         remote_dir = "/var/www/gforge-projects/cloudquery/"
+#         local_dir = 'rdoc'
+# 
+#         Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+#       end
+#     end
+#   end
+# rescue LoadError
+#   puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
+# end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 2

data/lib/cloudquery.rb

@@ -0,0 +1,453 @@
+require "rubygems"
+require "uri"
+require "digest/sha1"
+require "base64"
+require "rack/utils"
+require "curl"
+require "json"
+
+module Cloudquery
+  SCHEME = "https".freeze
+  HOST = "api.xoopit.com".freeze
+  PATH = "/v0".freeze
+
+  API_PATHS = {
+    :account => "account".freeze,
+    :schema => "schema".freeze,
+    :indexes => "i".freeze,
+    :documents => "i".freeze,
+  }.freeze
+  
+  # Standard Content-Types for requests
+  CONTENT_TYPES = {
+    :json => 'application/json;charset=utf-8'.freeze,
+    :form => 'application/x-www-form-urlencoded'.freeze,
+    :xml  => 'application/xml;charset=utf-8'.freeze,
+  }.freeze
+  
+
+  SIGNING_METHOD = "SHA1".freeze
+  COOKIE_JAR = ".cookies.lwp".freeze
+
+  class Request
+    attr_accessor :method, :headers, :scheme, :host, :port, :path, :params, :body
+
+    def initialize(options={})
+      @method = options[:method] || 'POST'
+      @headers = options[:headers] || {}
+      @scheme = options[:scheme] || SCHEME
+      @host = options[:host] || HOST
+      @port = options[:port] || (@scheme == 'https' ? URI::HTTPS::DEFAULT_PORT : URI::HTTP::DEFAULT_PORT)
+      @path = options[:path] || PATH
+      @params = options[:params] || {}
+      if ['PUT', 'DELETE'].include?(@method)
+        @params['_method'] = @method
+        @method = 'POST'
+      end
+      @body = options[:body]
+      
+      @account = options[:account]
+      @secret = options[:secret]
+    end
+
+    def request_uri(account=@account, secret=@secret)
+      query = query_str(signature_params(account))
+      uri = if query.empty?
+        @path.dup
+      else
+        "#{@path}?#{query}"
+      end
+      uri = append_signature(uri, secret) if secret
+      uri
+    end
+
+    def url(account=@account, secret=@secret)
+      base_uri.merge(request_uri(account, secret)).to_s
+    end
+
+    private
+    def append_signature(uri, secret)
+      sig = Crypto::URLSafeSHA1.sign(secret, uri)
+      x_sig = Rack::Utils.build_query("x_sig" => sig)
+      "#{uri}&#{x_sig}"
+    end
+
+    def signature_params(account=@account)
+      return {} unless account
+      {
+        'x_name' => account,
+        'x_time' => Time.now.to_i_with_milliseconds,
+        'x_nonce' => Cloudquery::Crypto::Random.nonce,
+        'x_method' => SIGNING_METHOD,
+      }
+    end
+
+    def query_str(additional_params={})
+      Rack::Utils.build_query(@params.dup.merge(additional_params))
+    end
+
+    def base_uri
+      uri_class = (@scheme == 'https' ? URI::HTTPS : URI::HTTP)
+      uri_class.build(:scheme => @scheme, :host => @host, :port => @port)
+    end
+
+  end
+
+  module Crypto
+    module Random
+      extend self
+
+      SecureRandom = (defined?(::SecureRandom) && ::SecureRandom) || (defined?(::ActiveSupport::SecureRandom) && ::ActiveSupport::SecureRandom)
+      if SecureRandom
+        def nonce
+          "#{SecureRandom.random_number}.#{Time.now.to_i}"[2..-1]
+        end
+      else
+        def nonce
+          "#{rand.to_s}.#{Time.now.to_i}"[2..-1]
+        end
+      end
+
+    end
+
+    module URLSafeSHA1
+      extend self
+
+      def sign(*tokens)
+        tokens = tokens.flatten
+        digest = Digest::SHA1.digest(tokens.join)
+        Base64.encode64(digest).chomp.tr('+/', '-_')
+      end
+
+    end
+  end
+
+  class Client
+    attr_reader :account
+    attr_writer :secret
+
+    # Create a new instance of the client
+    # +options = {}+ Acceptable options:
+    # +:account+ => <account name> (default => nil)
+    # +:secret+ => <API secret> (default => nil)
+    #
+    # +:document_id_method+ => <method name> (default => nil)
+    # will call +:document_id_method+ during +add_documents+
+    # and +update_documents+ which should inject an +'#.id'+
+    # key-value pair as a simple way to tie app PKs to doc ids.
+    #
+    # +:secure+ => Boolean (default => true, uses HTTPS)
+    # +:secure => false+ will use HTTP
+    def initialize(options={})
+      # unless options[:account] && options[:secret]
+      #   raise "Client requires :account => <account name> and :secret => <secret>"
+      # end
+      
+      @account = options[:account]
+      @secret = options[:secret]
+      
+      @secure = options[:secure] != false # must pass false for insecure
+      
+      @document_id_method = options[:document_id_method]
+    end
+
+
+    ## Account management
+    
+    # Retrieve the API secret for an account, using the password (uses HTTPS)
+    def self.get_secret(account, password)
+      auth = Request.new(:path => "#{PATH}/auth")
+      curl = Curl::Easy.new(auth.url) do |c|
+        c.enable_cookies = true
+        c.cookiejar = COOKIE_JAR
+      end
+      params = Rack::Utils.build_query({"name" => account, "password" => password})
+      curl.http_post(params)
+      
+      if curl.response_code == 200
+        curl.url = Request.new(:path => "#{PATH}/#{API_PATHS[:account]}/#{account}").url
+        curl.http_get
+        response = JSON.parse(curl.body_str)
+        response['result']['secret']
+      else
+        STDERR.puts "Error: #{curl.response_code} #{Rack::Utils::HTTP_STATUS_CODES[curl.response_code]}"
+      end
+    end
+
+    # Get the account document
+    def get_account
+      send_request get(account_path)
+    end
+    
+    # Update the account document.
+    # For example, you can use this method to change the API secret:
+    # update_account({'secret' => 'your-new-secret'})
+    def update_account(account_doc={})
+      body = JSON.generate(account_doc)
+      send_request put(account_path, body)
+    end
+    
+    # Delete the account. BEWARE: THIS WILL ACTUALLY DELETE YOUR ACCOUNT.
+    def delete_account
+      send_request delete(account_path)
+    end
+
+
+    ## Schema management
+    
+    # Add a schema to the account. xml can be a String
+    # or File-like (responds to read)
+    def add_schema(xml)
+      body = xml.respond_to?(:read) ? xml.read : xml
+      request = post(build_path(API_PATHS[:schema]), body)
+      send_request(request, CONTENT_TYPES[:xml])
+    end
+    
+    # Delete a schema from the account, by name
+    def delete_schema(schema_name)
+      send_request delete(build_path(
+        API_PATHS[:schema],
+        Rack::Utils.escape("xfs.schema.name:\"#{schema_name}\"")
+      ))
+    end
+    
+    # Get the schemas for the account.
+    # NOTE: returned format is not the same as accepted for input
+    def get_schemas
+      send_request get(build_path(API_PATHS[:schema]))
+    end
+    
+
+    ## Index management
+    
+    # Add one or more indexes to the account, by name or id
+    def add_indexes(*indexes)
+      body = JSON.generate(indexes.flatten)
+      send_request post(build_path(API_PATHS[:indexes]), body)
+    end
+    
+    # Delete one or more indexes from the account, by name or id
+    # +indexes = '*'+ will delete all indexes
+    def delete_indexes(*indexes)
+      indexes = url_pipe_join(indexes)
+      send_request delete(build_path(API_PATHS[:indexes], indexes))
+    end
+    
+    # Get the indexes from the account. Returns a list of ids
+    def get_indexes
+      send_request get(build_path(API_PATHS[:indexes]))
+    end
+    
+
+    ## Document management
+    
+    # Add documents to the specified +index+
+    # +index = name or id+, +docs = {}+ or Array of {}.
+    #
+    # Documents with key +'#.id'+ and an existing value will be updated.
+    #
+    # If +schemas+ is not nil, ensures existence of the
+    # specified schemas on each document.
+    def add_documents(index, docs, *schemas)
+      request = post(
+        build_path(API_PATHS[:documents], index, url_pipe_join(schemas)),
+        JSON.generate(identify_documents(docs))
+      )
+      send_request request
+    end
+    
+    # Update documents in the specified +index+
+    # +index = name or id+, +docs = {}+ or Array of {}.
+    #
+    # Documents lacking the key +'#.id'+ will be created.
+    #
+    # If +schemas+ is not nil, ensures existence of the
+    # specified schemas on each document.
+    def update_documents(index, docs, *schemas)
+      request = put(
+        build_path(API_PATHS[:documents], index, url_pipe_join(schemas)),
+        JSON.generate(identify_documents(docs))
+      )
+      send_request request
+    end
+    
+    # Modify documents in the +index+ matching +query+
+    # +modifications = {}+ to update all matching
+    # documents.
+    #
+    # If +schemas+ is not nil, ensures existence of the
+    # specified schemas on each document.
+    def modify_documents(index, query, modifications, *schemas)
+      request = put(
+        build_path(API_PATHS[:documents], index, url_pipe_join(schemas), Rack::Utils.escape(query)),
+        JSON.generate(modifications)
+      )
+      send_request request
+    end
+    
+    # Delete documents in the +index+ matching +query+
+    #
+    # +query+ defaults to +'*'+
+    # BEWARE: If +query = nil+ this will delete ALL documents in +index+.
+    #
+    # +index+ may be an id, index name, or Array of ids or names.
+    # Operates on all indexes if +index = nil+ or +'*'+
+    #
+    # If +schemas+ is not nil, ensures existence of the
+    # specified schemas on each document.
+    def delete_documents(index, query, *schemas)
+      request = delete(
+        build_path(API_PATHS[:documents],
+          url_pipe_join(index),
+          url_pipe_join(schemas),
+          Rack::Utils.escape(query)
+        )
+      )
+      send_request request
+    end
+    
+    # Get documents matching +query+
+    # 
+    # +query+ defaults to +'*'+
+    # +index+ may be an id, index name, or Array of ids or names.
+    # Operates on all indexes if +index = nil+ or +'*'+
+    #
+    # +options = {}+ Acceptable options:
+    # +:fields+ => a field name, a prefix match (e.g. +'trans*'+), or a list thereof (default => +'*'+)
+    # +:sort+ => a string ("[+|-]schema.field"), or a list thereof (default  => +'+#.number'+)
+    # +:offset+ => integer offset into the result set (default => +0+)
+    # +:limit+ => integer limit on number of documents returned per index (default => <no limit>)
+    #
+    # If +schemas+ is not nil, ensures existence of the
+    # specified schemas on each document.
+    def get_documents(index, query, options={}, *schemas)
+      if fields = options.delete(:fields)
+        fields = url_pipe_join(fields)
+      end
+      
+      if options[:sort]
+        options[:sort] = Array(options[:sort]).flatten.join(',')
+      end
+      
+      request = get(
+        build_path(API_PATHS[:documents], 
+          url_pipe_join(index), 
+          url_pipe_join(schemas),
+          url_pipe_join(query),
+          fields
+        ),
+        options
+      )
+      send_request request
+    end
+    
+    # Count documents matching +query+
+    # 
+    # +query+ defaults to +'*'+
+    # +index+ may be an id, index name, or Array of ids or names.
+    # Operates on all indexes if +index = nil+ or +'*'+
+    #
+    # If +schemas+ is not nil, ensures existence of the
+    # specified schemas on each document.
+    def count_documents(index, query, *schemas)
+      get_documents(index, query, {:fields => '@count'}, *schemas)
+    end
+    
+    private
+    def build_path(*path_elements)
+      path_elements.flatten.compact.unshift(PATH).join('/')
+    end
+    
+    def account_path
+      build_path(API_PATHS[:account], @account)
+    end
+    
+    def build_request(options={})
+      Request.new default_request_params.merge(options)
+    end
+    
+    def get(path, params={})
+      build_request(:method => 'GET', :path => path, :params => params)
+    end
+    
+    def delete(path, params={})
+      build_request(:method => 'DELETE', :path => path, :params => params)
+    end
+    
+    def post(path, doc, params={})
+      build_request(:method => 'POST', :path => path, :body => doc, :params => params)
+    end
+    
+    def put(path, doc, params={})
+      build_request(:method => 'PUT', :path => path, :body => doc, :params => params)
+    end
+    
+    def default_request_params
+      {
+        :account => @account,
+        :secret => @secret,
+        :scheme => @secure ? 'https' : 'http',
+      }
+    end
+    
+    def send_request(request, content_type=nil)
+      response = execute_request(request.method, request.url, request.headers, request.body, content_type)
+      status_code = response.first
+      if (200..299).include?(status_code)
+        begin
+          result = JSON.parse(response.last)
+        rescue JSON::ParserError => e
+          result = {"REASON" => e.message}
+        end
+      else
+        result = {"REASON" => "Error: #{status_code} #{Rack::Utils::HTTP_STATUS_CODES[status_code]}"}
+      end
+      result.merge!({'STATUS' => status_code})
+    end
+
+    def execute_request(method, url, headers, body, content_type=nil)
+      content_type ||= CONTENT_TYPES[:json]
+      curl = Curl::Easy.new(url) do |c|
+        c.headers = headers
+        c.headers['Content-Type'] = content_type
+        c.encoding = 'gzip'
+      end
+      case method
+      when 'GET'
+        curl.http_get
+      when 'DELETE'
+        curl.http_delete
+      when 'POST'
+        curl.http_post(body)
+      when 'PUT'
+        curl.http_put(body)
+      end
+      
+      [curl.response_code, curl.header_str, curl.body_str]
+    end
+
+    def url_pipe_join(arr, default_value='*')
+      arr = Array(arr).flatten
+      if arr.empty?
+        default_value
+      else
+        Rack::Utils.escape(arr.join('|'))
+      end
+    end
+    
+    def identify_documents(docs)
+      [docs] if docs.is_a?(Hash)
+      if @document_id_method
+        docs.each { |d| d.send(@document_id_method) }
+      end
+      docs
+    end
+  end
+end
+
+
+class Time
+  def to_i_with_milliseconds
+    (to_f * 1000).to_i
+  end
+end

data/spec/cloudquery_spec.rb

@@ -0,0 +1,437 @@
+require 'spec_helper'
+
+if ENV["TEST_REAL_HTTP"]
+  # Create a config.yml file containing the following:
+  # :account: <your account name>
+  # :secret: <your secret>
+  # then run the specs with TEST_REAL_HTTP=true
+  describe "CloudQuery account" do
+    before(:each) do
+      @config = YAML.load(File.read('config.yml'))
+      @client = Cloudquery::Client.new(@config)
+    end
+
+    it "gets your account information from the server" do
+      response = @client.get_account
+      response['STATUS'].should be_between(200, 299)
+      
+      account = response["result"]
+      account["secret"].should == @config[:secret]
+
+      account.should have_key("name")
+      account["name"].should == @config[:account]
+
+      account.should have_key("preferences")
+    end
+
+    it "updates your account on the server" do
+      account = @client.get_account["result"]
+      response = @client.update_account(account)
+      response['STATUS'].should be_between(200, 299)
+    end
+
+    it "adds a schema to your account on the server" do
+      response = @client.add_schema(File.open('spec/example_schema.xml'))
+      response['STATUS'].should be_between(200, 299)
+    end
+
+    it "gets the schemas for your account from the server" do
+      response = @client.get_schemas
+      response['STATUS'].should be_between(200, 299)
+      response['result'].should be_an_instance_of(Array)
+      response['result'].should have_at_least(1).item
+    end
+
+    it "deletes a schema from your account on the server" do
+      response = @client.delete_schema("spec.example")
+      response['STATUS'].should be_between(200, 299)
+    end
+
+    it "adds a single index to your account on the server" do
+      response = @client.add_indexes('spec_index')
+      response['STATUS'].should be_between(200, 299)
+      response['result'].should be_an_instance_of(Array)
+      response['result'].should have(1).item
+    end
+
+    it "adds multiple indexes to your account on the server" do
+      response = @client.add_indexes %w( spec_index_1 spec_index_2 spec_index_3 )
+      response['STATUS'].should be_between(200, 299)
+      response['result'].should be_an_instance_of(Array)
+      response['result'].should have(3).items
+    end
+
+    it "gets the indexes for your account from the server" do
+      response = @client.get_indexes
+      response['STATUS'].should be_between(200, 299)
+      response['result'].should be_an_instance_of(Array)
+      response['result'].should have_at_least(4).items
+    end
+
+    it "deletes a single index from your account on the server" do
+      response = @client.delete_indexes('spec_index')
+      response['STATUS'].should be_between(200, 299)
+      response['result'].should be_an_instance_of(Array)
+      response['result'].should have(1).item
+    end
+
+    it "deletes multiple indexes from your account on the server" do
+      response = @client.delete_indexes %w( spec_index_1 spec_index_2 spec_index_3 )
+      response['STATUS'].should be_between(200, 299)
+      response['result'].should be_an_instance_of(Array)
+      response['result'].should have(3).items
+    end
+
+    describe "document support" do
+      def valid_document
+        {
+            'spec.example.name' => 'Steve Rogers',
+            'spec.example.email' => ['steve.rogers@example.com','captain.america@marvel.com'],
+            'spec.example.telephone' => ['555-555-5555','123-456-6789'],
+            'spec.example.address' => ['Lower East Side, NY NY'],
+            'spec.example.birthday' => ParseDate.parsedate('July 4, 1917'),
+            'spec.example.note' => 'Captain America!',
+        }
+      end
+      
+      def add_valid_document(index=nil)
+        index ||= 'spec_index'
+        response = @client.add_documents(index, valid_document, 'spec.example')
+        response['result'].first
+      end
+      
+      before(:each) do
+        @client.add_indexes('spec_index')
+        @client.add_schema(File.open('spec/example_schema.xml'))
+      end
+
+      after(:each) do
+        @client.delete_schema("spec.example")
+        @client.delete_indexes('spec_index')
+      end
+
+      it "adds a document to an index on the server" do
+        response = @client.add_documents('spec_index', valid_document, 'spec.example')
+        response['STATUS'].should == 201
+        response['result'].should have(1).item
+      end
+
+      it "adds multiple documents to an index on the server" do
+        documents = [
+          valid_document,
+          {
+            'spec.example.name' => 'Clark Kent',
+            'spec.example.email' => ['clark.kent@example.com','superman@dc.com'],
+            'spec.example.telephone' => ['555-123-1234', '555-456-6789'],
+            'spec.example.address' => 
+              ['344 Clinton St., Apt. #3B, Metropolis', 'The Fortess of Solitude, North Pole'],
+            'spec.example.birthday' => ParseDate.parsedate('June 18, 1938'),
+            'spec.example.note' => 
+              'Superhuman strength, speed, stamina, durability, senses, intelligence, regeneration, and longevity; super breath, heat vision, x-ray vision and flight. Member of the justice league.',
+          },
+          {
+            'spec.example.name' => 'Bruce Wayne',
+            'spec.example.email' => ['bruce.wayne@example.com','batman@dc.com'],
+            'spec.example.telephone' => ['555-123-6666', '555-456-6666'],
+            'spec.example.address' => 
+              ['1007 Mountain Drive, Gotham', 'The Batcave, Gotham'],
+            'spec.example.birthday' => ParseDate.parsedate('February 19, 1939'),
+            'spec.example.note' => 
+              'Sidekick is Robin. Has problems with the Joker. Member of the justice league.',
+          },
+        ]
+
+        response = @client.add_documents('spec_index', documents, 'spec.example')
+        response['STATUS'].should == 201
+        response['result'].should have(3).items
+      end
+
+      it "updates a document on the server" do
+        doc = valid_document
+        doc['#.#'] = add_valid_document
+        doc['spec.example.note'] = "Document modified!"
+
+        response = @client.update_documents('spec_index', doc, 'spec.example')
+        response['STATUS'].should == 200
+        response['result'].should have(1).item
+      end
+
+      it "modifies documents on the server" do
+        add_valid_document
+        mods = {'spec.example.note' => 'Document modified!'}
+        response = @client.modify_documents(
+          "spec_index",
+          "name:#{valid_document['spec.example.name']}",
+          mods,
+          "spec.example"
+        )
+        response['STATUS'].should == 200 # OK
+        response['result'].should have(1).item
+      end
+
+      it "gets a document from the server" do
+        add_valid_document
+        response = @client.get_documents('spec_index', nil, {}, 'spec.example')
+        response['STATUS'].should == 200
+        response['result'].should have(1).item
+        stored_document = response['result'].first
+        valid_document.each { |key, value| stored_document.should have_key(key) }
+      end
+      
+      it "gets a document from multiple indexes on the server" do
+        @client.add_indexes('spec_index_2')
+        @client.delete_documents(nil, nil)
+        add_valid_document
+        add_valid_document('spec_index_2')
+
+        response = @client.get_documents(nil, nil, {}, 'spec.example')
+        response['STATUS'].should == 200
+        response['result'].should have(2).items
+        stored_document_1 = response['result'].first
+        stored_document_2 = response['result'].last
+
+        valid_document.each { |key, value| stored_document_1.should have_key(key) }
+        valid_document.each { |key, value| stored_document_2.should have_key(key) }
+        
+        @client.delete_indexes('spec_index_2')
+      end
+      
+      it "counts documents from the server" do
+        @client.delete_documents(nil, nil)
+        add_valid_document
+        
+        response = @client.count_documents('spec_index', '*', 'spec.example')
+        response['STATUS'].should == 200
+        response['result'].should == 1
+      end
+    end
+  end
+end
+
+describe Cloudquery::Client do
+  before(:each) do
+    @valid_options = {
+      :account => 'account',
+      :secret => 'secret'
+    }
+  end
+  
+  def client(options={})
+    return @client if defined?(@client)
+    @client = Cloudquery::Client.new(@valid_options.merge(options))
+    @client.stub!(:execute_request)
+    @client
+  end
+  
+  it "instantiates when passed valid arguments" do
+    lambda { client }.should_not raise_error
+  end
+    
+end
+
+describe Cloudquery::Request do
+  before(:each) do
+    @valid_options = {
+      :scheme => 'http',
+      :host => 'example.com',
+      :path => '/super/duper/path',
+    }
+  end
+  
+  def request(additional_options={})
+    return @request if defined?(@request)
+    @request = Cloudquery::Request.new(@valid_options.merge(additional_options))
+  end
+
+  it "instantiates with valid options" do
+    lambda { request }.should_not raise_error
+  end
+
+  describe "request_uri" do
+    describe "without an account or secret" do
+      it "appends the query_str to the path after '?'" do
+        request.should_receive(:query_str).at_least(:once).and_return("query=string&more=params")
+        request.request_uri.should == "#{request.path}?#{request.send(:query_str)}"
+      end
+      
+      it "doesn't append a '?' when query_str is empty" do
+        request.should_receive(:query_str).at_least(:once).and_return("")
+        request.request_uri.should == request.path
+        request.request_uri.should_not equal(request.path) #ensure we don't accidentally modify request's instance variable
+      end
+    end
+    
+    describe "with an account" do
+      it "should append the signature_params" do
+        params = request(:account => 'account').request_uri.sub(/^[^?]+\?/, '').split('&')
+        params.select { |n| n.match(/^x_/) }.should have(4).items
+      end
+      
+      describe "and a secret" do
+        it "should append the signature when the secret is provided" do
+          params = request(:account => 'account', :secret => 'secret').request_uri.sub(/^[^?]+\?/, '').split('&')
+          x_params = params.select { |n| n.match(/^x_/) }
+          x_params.should have(5).items
+          x_params.last.should match(/^x_sig=[0-9a-zA-Z\-._%]+/)
+        end
+      end
+    end
+  end
+  
+  describe "url" do
+    it "constructs a full URL from the scheme, host, and request_uri" do
+      request.url.should == 
+        "#{request.scheme}://#{request.host}#{request.request_uri}"
+    end
+    
+    it "constructs a url using a port override" do
+      request(:port => 8080).url.should == 
+        "#{request.scheme}://#{request.host}:8080#{request.request_uri}"
+    end
+    
+    it "constructs a url using a path override" do
+      request(:path => '/another/path').url.should == 
+        "#{request.scheme}://#{request.host}#{request.request_uri}"
+    end
+    
+    it "constructs a url with default query parameters" do
+      request(:params => {'these' => 'params'}).url.should ==
+        "#{request.scheme}://#{request.host}#{request.request_uri}"
+      request.url.should match(/these=params$/)
+    end
+
+    describe "without an account or secret" do
+      it "does not append the x_<params>" do
+        request.url.should_not match(/x_/)
+      end
+    end
+    
+    describe "with an account" do
+      it "appends the signature params" do
+        url = request(:account => 'account').url
+        query = Rack::Utils.parse_query(url.split('?').last)
+        request.send(:signature_params).keys.each do |param_name|
+          query.should have_key(param_name)
+        end
+      end
+
+      describe "and a secret" do
+        it "appends the signature params and x_sig with the signature" do
+          url = request(:account => 'account', :secret => 'secret').url
+          query = Rack::Utils.parse_query(url.split('?').last)
+          signature_params = request.send(:signature_params).keys
+          signature_params.each do |param_name|
+            query.should have_key(param_name)
+          end
+          query.should have_key('x_sig')
+        end
+      end
+    end
+  end
+  
+  describe "private methods" do
+    
+    describe "append_signature" do
+      it "should append the signature as the x_sig parameter at the end of the query string" do
+        url = 'http://example.com/path?query=string'
+        signed_url = request.send(:append_signature, url, 'secret')
+        signed_url.should match(/^#{url.sub(/\?/, '\\?')}/)
+        signed_url.should match(/x_sig=[-\w]+(?:%3D)*$/)
+      end
+    end
+
+    describe "signature_params" do
+      describe "without an account present" do
+        it "should return an empty hash" do
+          request.send(:signature_params).should == {}
+        end
+      end
+
+      describe "with an account present" do
+        before(:each) do
+          @params = request(:account => 'account').send(:signature_params)
+        end
+
+        it "should return a hash with the x_name parameter with the account name" do
+          @params.should have_key('x_name')
+          @params['x_name'].should == 'account'
+        end
+
+        it "should return a hash with the x_time parameter with the current milliseconds since epoch" do
+          @params.should have_key('x_time')
+          @params['x_time'].should be_close(Time.now.to_i_with_milliseconds, 100)
+        end
+
+        it "should return a hash with the x_nonce parameter of the format \d+.\d+" do
+          @params.should have_key('x_nonce')
+          @params['x_nonce'].should match(/^\d+.\d+$/)
+        end
+
+        it "should return a hash with the x_method parameter with the signing method name" do
+          @params.should have_key('x_method')
+          @params['x_method'].should == Cloudquery::SIGNING_METHOD
+        end
+      end
+    end
+
+    describe "query_str" do
+      it "builds a query string from the request params" do
+        request(:params => {'these' => 'params'})
+        request.send(:query_str).should == 'these=params'
+      end
+
+      it "url-encodes params with non alphanumeric characters (outside [ a-zA-Z0-9-._])" do
+        request(:params => {'weird' => 'values=here'})
+        request.send(:query_str).should == 'weird=values%3Dhere'
+      end
+
+      it "returns an empty string when no params are present" do
+        request(:params => {}).send(:query_str) == ""
+      end
+    end
+
+    describe "base_uri" do
+      it "returns an http url when the scheme is http" do
+        request(:scheme => 'http').send(:base_uri).should be_an_instance_of(URI::HTTP)
+      end
+      it "returns an https url when the scheme is https" do
+        request(:scheme => 'https').send(:base_uri).should be_an_instance_of(URI::HTTPS)
+      end
+    end
+  end
+
+end
+
+describe Cloudquery::Crypto::Random do
+  describe "nonce generation" do
+    it "generates a nonce with a random number, a dot, and the current time" do
+      nonce = Cloudquery::Crypto::Random.nonce
+      nonce.should match(/^\d+.\d+$/)
+      random_digits, time = nonce.split('.')
+      time.to_i.should be_close(Time.now.to_i, 1)
+      random_digits.should match(/^\d+$/)
+    end
+  end
+end
+
+describe Cloudquery::Crypto::URLSafeSHA1 do
+  describe "sign" do
+    it "takes an arbitrary number of tokens to encrypt" do
+      lambda { Cloudquery::Crypto::URLSafeSHA1.sign }.should_not raise_error
+      lambda { Cloudquery::Crypto::URLSafeSHA1.sign('a') }.should_not raise_error
+      lambda { Cloudquery::Crypto::URLSafeSHA1.sign('a', 'b', 'c') }.should_not raise_error
+    end
+    
+    it "produces a url-safe base64 encoded SHA1 digest of tokens" do
+      20.times do
+        token = Cloudquery::Crypto::Random.nonce
+        signature = Cloudquery::Crypto::URLSafeSHA1.sign(token)
+        signature.should_not include('+')
+        signature.should_not include('/')
+
+        b64_digest = Base64.encode64(Digest::SHA1.digest(token)).chomp.tr('+/', '-_')
+        signature.should == b64_digest
+      end
+    end
+  end
+end

data/spec/example_schema.xml

@@ -0,0 +1,26 @@
+<schema name="spec.example" store="yes">
+    <!-- The full name of the contact -->
+    <field name="name"
+           type="string"
+           analyzer="LCWhitespaceAnalyzer"
+           usage="user" />
+    <!-- The email addresses. A json array: email address -->
+    <field name="email"
+           type="string"
+           usage="user" />
+    <!-- The phone numbers. A json array: phone number -->
+    <field name="telephone"
+           type="string"
+           usage="user" />
+    <!-- The addresses. A json array: address -->
+    <field name="address"
+           type="string"
+           usage="user" />
+    <!-- The birthday of the contact-->
+    <field name="birthday"
+           type="date" />
+    <!-- A note for the contact-->
+    <field name="note"
+           type="text"
+           usage="user" />
+</schema>

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'cloudquery'
+require 'parsedate'
+require 'pp'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: xoopit-cloudquery
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Cameron Walters
+- nb.io
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-03 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: taf2-curb
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.8.0
+    version: 
+description: Client for Xoopit's cloudquery API
+email: us@nb.io
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION.yml
+- lib/cloudquery.rb
+- spec/cloudquery_spec.rb
+- spec/example_schema.xml
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/nbio/cloudquery
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Client for Xoopit's cloudquery API
+test_files: 
+- spec/cloudquery_spec.rb
+- spec/spec_helper.rb