cdd 0.0.1 → 0.0.2

data/README.md

@@ -25,6 +25,7 @@ require 'cdd'
 cdd = CDD::Client.new(YOUR_TOKEN)
 ```
 
+## Vaults
 Retrieve your vaults
 
 ```ruby
@@ -36,7 +37,8 @@ Returns a list of vault objects that look like:
 [{"name"=>"Your Vault Name", "id"=>1234}]
 ```
 
-With a vault object, you can retrieve it's project list:
+## Projects
+Given a vault object, you can retrieve it's project list:
 ```ruby
 projects = vaults.first.projects
 ```
@@ -46,6 +48,77 @@ Returns a list of project objects that look like:
 [{"name"=>"Your Project Name", "id"=>1234}]
 ```
 
+## Searches
+Given a vault object, you can retrieve it's searches list:
+```ruby
+projects = vaults.first.searches
+```
+
+Returns a list of searches objects that look like:
+```ruby
+[{"name"=>"Your Search Name", "id"=>1234}]
+```
+
+## Exporting
+With a ```Search``` object and one or more ```Project``` objects, you can export matching data.
+
+### Synchronous Export
+The simplest way to export data is using the ```Search#export``` method. The CDD API is asynchronous, this method wraps the API in a synchronous method. You can use in two ways:
+
+```ruby
+require 'cdd'
+
+cdd = CDD::Client.new(YOUR_TOKEN)
+vaults = cdd.vaults
+vault = vaults.first
+search = vault.searches.first
+projects = vault.projects
+data = search.export(projects, "csv") # The second parameter defaults to CSV and can be omitted.
+puts data
+```
+
+Or by using the block syntax, this time in SDF format:
+
+```ruby
+require 'cdd'
+
+cdd = CDD::Client.new(YOUR_TOKEN)
+vaults = cdd.vaults
+vault = vaults.first
+search = vault.searches.first
+projects = vault.projects
+search.export(projects, "sdf") do |data|
+  puts data
+end
+```
+
+### Asynchronous Export
+
+The synchronous export method is provided as a courtesy. If you could be exporting any non-trivial amount of data, you should use the aynchronous method.
+
+To begin an export using the method ```Search#start_export```. This will return an ```Export``` object which can be polled or used to retrieve data.
+
+```ruby
+require 'cdd'
+
+cdd = CDD::Client.new(YOUR_TOKEN)
+vaults = cdd.vaults
+vault = vaults.first
+search = vault.searches.first
+projects = vault.projects
+export = search.start_export(projects, "sdf")
+export_state = export.poll
+puts export_state["status"]
+```
+
+When ```export.poll["status"] == "finished"``` the export is complete and can be downloaded. You retrieve the data with the following method:
+
+```ruby
+export.data
+```
+
+That will return a string containing either the CSV or SDF results.
+
 ## Contributing
 
 1. Fork it

data/Rakefile

@@ -1,2 +1,8 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :test => :spec
+task :default => :spec

data/lib/cdd/base.rb

@@ -0,0 +1,13 @@
+module CDD
+  class Base
+    attr_accessor :id
+    attr_accessor :client
+
+    def initialize(client, options={})
+      self.client = client
+      options.each do |k,v|
+        self.send("#{k}=",v)
+      end
+    end
+  end
+end

data/lib/cdd/client.rb

@@ -12,12 +12,12 @@ module CDD
     end
 
     def vaults
-      execute(vaults_uri).collect do |hash|
+      @vaults ||= execute(vaults_url).collect do |hash|
         CDD::Vault.new(self,hash)
       end
     end
 
-    def vaults_uri
+    def vaults_url
       "/api/v1/vaults"
     end
 

data/lib/cdd/export.rb

@@ -0,0 +1,25 @@
+module CDD
+  class Export < Base
+    attr_accessor :format
+    attr_accessor :status
+    attr_accessor :search
+    attr_accessor :vault
+
+    def poll
+      client.execute(poll_url)
+    end
+
+    def poll_url
+      "/api/v1/vaults/#{vault.id}/export_progress/#{self.id}"
+    end
+
+    def data
+      response = RestClient.get "#{client.url}#{data_url}", { :params => {}, "X-CDD-Token" => client.token }
+      response.to_s if response
+    end
+
+    def data_url
+      "/api/v1/vaults/#{vault.id}/exports/#{id}"
+    end
+  end
+end

data/lib/cdd/project.rb

@@ -1,22 +1,6 @@
 module CDD
-  class Project
-    attr_accessor :id
+  class Project < Base
     attr_accessor :name
-    attr_accessor :client
-
-    def initialize(client, options={})
-      self.client = client
-      options.each do |k,v|
-        self.send("#{k}=",v)
-      end
-    end
-
-    def projects
-      client.execute(projects_url)
-    end
-
-    def projects_url
-      "/api/v1/vaults/#{self.id}/projects"
-    end
+    attr_accessor :vault
   end
 end

data/lib/cdd/search.rb

@@ -0,0 +1,27 @@
+module CDD
+  class Search < Base
+    attr_accessor :name
+    attr_accessor :vault
+
+    def start_export(projects=[], format="csv")
+      project_ids = projects.collect { |p| p.id }
+      params = { :search => self.id, :projects => project_ids }
+      result = JSON.parse(RestClient.post("#{client.url}#{vault.export_url(format)}", params, { "X-CDD-Token" => client.token }))
+      CDD::Export.new(client, { :search => self, :vault => vault, :format => format }.merge(result))
+    end
+
+    def export(projects=[], format="csv", &block)
+      e = start_export(projects, format)
+      state = e.poll
+      while ["new", "started", "starting"].include?(state["status"]) do
+        state = e.poll
+      end
+      data = e.data
+      if block
+        return block.call(data)
+      else
+        return data
+      end
+    end
+  end
+end

data/lib/cdd/vault.rb

@@ -1,24 +1,29 @@
 module CDD
-  class Vault
-    attr_accessor :id
+  class Vault < Base
     attr_accessor :name
-    attr_accessor :client
-
-    def initialize(client, options={})
-      self.client = client
-      options.each do |k,v|
-        self.send("#{k}=",v)
-      end
-    end
 
     def projects
-      client.execute(projects_url).collect do |hash|
-        CDD::Project.new(self.client, hash)
+      @project ||= client.execute(projects_url).collect do |hash|
+        CDD::Project.new(self.client, {:vault => self}.merge(hash))
       end
     end
 
     def projects_url
       "/api/v1/vaults/#{self.id}/projects"
     end
+
+    def searches
+      @searches ||= client.execute(searches_url).collect do |hash|
+        CDD::Search.new(client, {:vault => self}.merge(hash))
+      end
+    end
+
+    def searches_url
+      "/api/v1/vaults/#{self.id}/searches"
+    end
+
+    def export_url(format="csv")
+      "/api/v1/vaults/#{self.id}/exports.#{format}"
+    end
   end
 end

data/lib/cdd/version.rb

@@ -1,3 +1,3 @@
 module CDD
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/cdd.rb

@@ -1,4 +1,7 @@
+require "cdd/base"
 require "cdd/client"
+require "cdd/export"
 require "cdd/project"
+require "cdd/search"
 require "cdd/vault"
 require "cdd/version"

data/spec/cdd_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe CDD do
+
+  context "A default client" do
+    context "when requesting vaults" do
+      let(:token) { ENV["CDD_TOKEN_ID"] || "1234567890" }
+      let(:client) { CDD::Client.new(token) }
+
+      it "should have the correct vaults_url" do
+        client.vaults_url.should == "/api/v1/vaults"
+      end
+
+      it "should call the default vaults url" do
+        RestClient.should_receive(:get).with("https://app.collaborativedrug.com/api/v1/vaults", { :params=>{} , "X-CDD-Token" => token}).and_return(fake_response([{:id => "1234", :name => "Test Vault"}].to_json))
+        client.vaults
+      end
+
+      context "when requesting vaults" do
+        before(:all) do
+          RestClient.stub(:get).with("https://app.collaborativedrug.com/api/v1/vaults", { :params=>{} , "X-CDD-Token" => token}).and_return(fake_response([{:id => "1234", :name => "Test Vault"}].to_json))
+        end
+        let(:vaults) { client.vaults }
+
+        it "should return an array of vaults" do
+          vaults.class.should == Array
+          vaults.first.class.should == CDD::Vault
+        end
+
+        context "the vault" do
+          let(:vault) { vaults.first }
+
+          it "should have the correct values" do
+            vault.id.should == "1234"
+            vault.name.should == "Test Vault"
+          end
+
+          it "should have the correct default export_url" do
+            vault.export_url.should == "/api/v1/vaults/#{vault.id}/exports.csv"
+          end
+
+          it "should have the correct csv export_url" do
+            vault.export_url("csv").should == "/api/v1/vaults/#{vault.id}/exports.csv"
+          end
+
+          it "should have the correct sdf export_url" do
+            vault.export_url("sdf").should == "/api/v1/vaults/#{vault.id}/exports.sdf"
+          end
+
+          it "should have the correct searches_url" do
+            vault.searches_url.should == "/api/v1/vaults/#{vault.id}/searches"
+          end
+
+          it "should call the default searches url" do
+            RestClient.should_receive(:get).with("https://app.collaborativedrug.com/api/v1/vaults/#{vault.id}/searches", { :params=>{} , "X-CDD-Token" => token}).and_return(fake_response([{:id => "12345", :name => "Test Search"}].to_json))
+            vault.searches
+          end
+
+          context "when requesting searches" do
+            before(:all) do
+              RestClient.stub(:get).with("https://app.collaborativedrug.com/api/v1/vaults/#{vault.id}/searches", { :params=>{} , "X-CDD-Token" => token}).and_return(fake_response([{:id => "12345", :name => "Test Search"}].to_json))
+            end
+            let(:searches) { vault.searches }
+
+            it "should return an array of searches" do
+              searches.class.should == Array
+              searches.first.class.should == CDD::Search
+            end
+
+            context "the search" do
+              let(:search) { searches.first }
+
+              it "should have the correct values" do
+                search.id.should == "12345"
+                search.name.should == "Test Search"
+              end
+            end
+          end
+
+          it "should have the correct projects_url" do
+            vaults.first.projects_url.should == "/api/v1/vaults/#{vaults.first.id}/projects"
+          end
+
+          it "should call the default projects url" do
+            RestClient.should_receive(:get).with("https://app.collaborativedrug.com/api/v1/vaults/#{vaults.first.id}/projects", { :params=>{} , "X-CDD-Token" => token}).and_return(fake_response([{:id => "123456", :name => "Test Project"}].to_json))
+            vault.projects
+          end
+
+          context "when requesting projects" do
+            before(:all) do
+              RestClient.stub(:get).with("https://app.collaborativedrug.com/api/v1/vaults/#{vaults.first.id}/projects", { :params=>{} , "X-CDD-Token" => token}).and_return(fake_response([{:id => "123456", :name => "Test Project"}].to_json))
+            end
+            let(:projects) { vault.projects }
+
+            it "should return an array of projects" do
+              projects.class.should == Array
+              projects.first.class.should == CDD::Project
+            end
+
+            context "the project" do
+              let(:project) { projects.first }
+
+              it "should have the correct values" do
+                project.id.should == "123456"
+                project.name.should == "Test Project"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context "A client with a custom url" do
+    context "when requesting vaults" do
+      let(:token) { ENV["CDD_TOKEN_ID"] || "1234567890" }
+      let(:client) { CDD::Client.new(token, :url => "http://example.com") }
+
+      it "should call the custom vaults url" do
+        RestClient.should_receive(:get).with("http://example.com/api/v1/vaults", { :params=>{} , "X-CDD-Token" => token}).and_return(fake_response([{:id => "1234", :name => "Test Vault"}].to_json))
+        vaults = client.vaults
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'cdd'
+
+def fake_response(body)
+  net_http_resp = Net::HTTPResponse.new(1.0, 200, "OK")
+  # net_http_resp.add_field 'Set-Cookie', 'Monster'
+  RestClient::Response.create(body, net_http_resp, nil)
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cdd
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-17 00:00:00.000000000 Z
+date: 2013-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -89,10 +89,15 @@ files:
 - Rakefile
 - cdd.gemspec
 - lib/cdd.rb
+- lib/cdd/base.rb
 - lib/cdd/client.rb
+- lib/cdd/export.rb
 - lib/cdd/project.rb
+- lib/cdd/search.rb
 - lib/cdd/vault.rb
 - lib/cdd/version.rb
+- spec/cdd_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/cpetersen/cdd
 licenses: []
 post_install_message: 
@@ -107,7 +112,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2264778669571184428
+      hash: 3887554079488693763
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -116,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2264778669571184428
+      hash: 3887554079488693763
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -124,4 +129,6 @@ signing_key:
 specification_version: 3
 summary: Collaborative Drug Discovery is a web based tool for storing and sharing
   pharmaceutical research. This is a ruby wrapper for their API.
-test_files: []
+test_files:
+- spec/cdd_spec.rb
+- spec/spec_helper.rb