biomart 0.1.3 → 0.1.4

data/History.txt

@@ -1,3 +1,8 @@
+=== 0.1.4 2010-01-20
+
+* 1 minor enhancement:
+  * Added in the ability to override the default timeout on requests.
+
 === 0.1.3 2009-10-30
 
 * 1 major bugfix:

data/Manifest.txt

@@ -12,6 +12,7 @@ lib/biomart/server.rb
 script/console
 script/destroy
 script/generate
-tasks/shoulda.rake
+tasks/metrics.task
+tasks/shoulda.task
 test/test_biomart.rb
 test/test_helper.rb

data/README.rdoc

@@ -2,7 +2,7 @@
 
 http://github.com/dazoakley/biomart
 
-http://rubyforge.org/projects/biomart
+http://rdoc.info/projects/dazoakley/biomart
 
 Biomart provides a simple interface for working with Biomart servers 
 (see http://www.biomart.org for more info on Biomart itself), so you 
@@ -92,13 +92,28 @@ Now all requests made through Biomart will be proxied via proxy.example.com.
 Alternatively you can also set your proxy url in the environment variable 
 'http_proxy', and Biomart will automatically detect this.
 
+== Setting a Timeout Value
+
+If you need to alter the default request timeout value, you can alter this 
+globally via Biomart.timeout:
+
+  Biomart.timeout = 60     # For a 60 second timeout...
+
+Or on a per-request basis by passing the :timeout option when searching:
+
+  kermits.search( 
+    :filters         => { "marker_symbol" => "Cbx1" }, 
+    :process_results => true, 
+    :timeout         => 60
+  )
+
 == Meta
 
 Written by Darren Oakley (daz dot oakley at gmail dot com)
 
 http://github.com/dazoakley/biomart
 
-http://rubyforge.org/projects/biomart
+http://rdoc.info/projects/dazoakley/biomart
 
 == License
 

data/Rakefile

@@ -22,7 +22,7 @@ $hoe = Hoe.spec "biomart" do
 end
 
 require "newgem/tasks"
-Dir["tasks/**/*.rake"].each { |t| load t }
+Dir["tasks/*.task"].each { |t| load t }
 
 # TODO - want other tests/tasks run by default? Add them to the list
 # remove_task :default

data/biomart.gemspec

@@ -2,15 +2,15 @@
 
 Gem::Specification.new do |s|
   s.name = %q{biomart}
-  s.version = "0.1.3"
+  s.version = "0.1.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Darren Oakley"]
-  s.date = %q{2009-10-30}
+  s.date = %q{2010-01-20}
   s.description = %q{A ruby API for interacting with Biomart services.}
   s.email = ["daz.oakley@gmail.com"]
   s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc"]
-  s.files = ["History.txt", "Manifest.txt", "README.rdoc", "Rakefile", "biomart.gemspec", "lib/biomart.rb", "lib/biomart/attribute.rb", "lib/biomart/database.rb", "lib/biomart/dataset.rb", "lib/biomart/filter.rb", "lib/biomart/server.rb", "script/console", "script/destroy", "script/generate", "tasks/shoulda.rake", "test/test_biomart.rb", "test/test_helper.rb"]
+  s.files = ["History.txt", "Manifest.txt", "README.rdoc", "Rakefile", "biomart.gemspec", "lib/biomart.rb", "lib/biomart/attribute.rb", "lib/biomart/database.rb", "lib/biomart/dataset.rb", "lib/biomart/filter.rb", "lib/biomart/server.rb", "script/console", "script/destroy", "script/generate", "tasks/metrics.task", "tasks/shoulda.task", "test/test_biomart.rb", "test/test_helper.rb"]
   s.homepage = %q{http://github.com/dazoakley/biomart}
   s.rdoc_options = ["--main", "README.rdoc"]
   s.require_paths = ["lib"]

data/lib/biomart.rb

@@ -6,8 +6,16 @@ require "csv"
 require "rubygems"
 require "builder"
 
+#begin
+#  require "curb"
+#  use_curb = true
+#rescue LoadError
+#  use_curb = false
+#end
+#CURB_AVAILABLE = use_curb
+
 module Biomart
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
   
   # This is the base Biomart error/exception class. Rescue it if 
   # you want to catch any exceptions that this code might raise.
@@ -38,50 +46,122 @@ module Biomart
   # dataset.
   class DatasetError   < BiomartError; end
   
-  @@url    = 'http://www.biomart.org/biomart/martservice'
-  @@client = Net::HTTP
-  
   # Centralised request function for handling all of the HTTP requests 
   # to the biomart servers.
   def request( params={} )
-    if Biomart.proxy or ENV['http_proxy']
-      proxy_uri = Biomart.proxy
-      proxy_uri ||= ENV['http_proxy']
-      proxy = URI.parse( proxy_uri )
-      @@client = Net::HTTP::Proxy( proxy.host, proxy.port )
-    end
+    net_http_request(params)
     
-    params[:url] = URI.escape(params[:url])
+    #if CURB_AVAILABLE and ( Biomart.use_net_http != true )
+    #  curb_request(params)
+    #else
+    #  net_http_request(params)
+    #end
+  end
+  
+  class << self
+    attr_accessor :proxy, :timeout, :use_net_http
+  end
+  
+  private
     
-    if params[:method] === 'post'
-      res = @@client.post_form( URI.parse(params[:url]), { "query" => params[:query] } )
-    else
-      res = @@client.get_response( URI.parse(params[:url]) )
+    # Utility function to perform the request method using the curb 
+    # gem (a wrapper around libcurl) - supposed to be faster than 
+    # Net::HTTP.
+    def curb_request( params={} )
+      client = Curl::Easy.new( params[:url] )
+      
+      if Biomart.timeout or params[:timeout]
+        client.connect_timeout = params[:timeout] ? params[:timeout] : Biomart.timeout
+      end
+      
+      if proxy_url() then client.proxy_url = proxy_url() end
+      
+      case params[:method]
+      when 'post'
+        client.http_post( Curl::PostField.content( "query", params[:query], "text/xml" ) )
+      else
+        client.http_get
+      end
+      
+      check_response( client.body_str, client.response_code )
+      
+      return client.body_str
     end
     
-    # Process the response code/body to catch errors.
-    if res.code != "200"
-      raise HTTPError.new(res.code), "HTTP error #{res.code}, please check your biomart server and URL settings."
-    else
-      if res.body =~ /ERROR/
-        if res.body =~ /Filter (.+) NOT FOUND/
-          raise FilterError.new(res.body), "Biomart error. Filter #{$1} not found."
-        elsif res.body =~ /Attribute (.+) NOT FOUND/
-          raise AttributeError.new(res.body), "Biomart error. Attribute #{$1} not found."
-        elsif res.body =~ /Dataset (.+) NOT FOUND/
-          raise DatasetError.new(res.body), "Biomart error. Dataset #{$1} not found."
-        else
-          raise BiomartError.new(res.body), "Biomart error."
+    # Utility function to perform the request method using Net::HTTP.
+    def net_http_request( params={} )
+      uri          = URI.parse( params[:url] )
+      client       = net_http_client()
+      req          = nil
+      response     = nil
+
+      case params[:method]
+      when 'post'
+        req           = Net::HTTP::Post.new(uri.path)
+        req.form_data = { "query" => params[:query] }
+      else
+        req           = Net::HTTP::Get.new(uri.request_uri)
+      end
+
+      client.start(uri.host, uri.port) do |http|
+        if Biomart.timeout or params[:timeout]
+          http.read_timeout = params[:timeout] ? params[:timeout] : Biomart.timeout
+          http.open_timeout = params[:timeout] ? params[:timeout] : Biomart.timeout
         end
+        response = http.request(req)
+      end
+
+      check_response( response.body, response.code )
+
+      return response.body
+    end
+    
+    # Utility function to create a Net::HTTP object.
+    def net_http_client
+      client = Net::HTTP
+      if proxy_url()
+        proxy  = URI.parse( proxy_url() )
+        client = Net::HTTP::Proxy( proxy.host, proxy.port )
       end
+      return client
     end
     
-    return res.body
-  end
-  
-  class << self
-    attr_accessor :proxy
-  end
+    # Utility function to determine if we need to use a proxy. If yes, 
+    # returns the proxy url, if no, returns false.
+    def proxy_url
+      if Biomart.proxy or ENV['http_proxy'] or ENV['HTTP_PROXY']
+        proxy_uri = Biomart.proxy
+        proxy_uri ||= ENV['http_proxy']
+        proxy_uri ||= ENV['HTTP_PROXY']
+        
+        return proxy_uri
+      else
+        return false
+      end
+    end
+    
+    # Utility function to test the response from a http request. 
+    # Raises errors if appropriate.
+    def check_response( body, code )
+      # Process the response code/body to catch errors.
+      if code.is_a?(String) then code = code.to_i end
+      
+      if code != 200 
+        raise HTTPError.new(code), "HTTP error #{code}, please check your biomart server and URL settings."
+      else
+        if body =~ /ERROR/
+          if body =~ /Filter (.+) NOT FOUND/
+            raise FilterError.new(body), "Biomart error. Filter #{$1} not found."
+          elsif body =~ /Attribute (.+) NOT FOUND/
+            raise AttributeError.new(body), "Biomart error. Attribute #{$1} not found."
+          elsif body =~ /Dataset (.+) NOT FOUND/
+            raise DatasetError.new(body), "Biomart error. Dataset #{$1} not found."
+          else
+            raise BiomartError.new(body), "Biomart error."
+          end
+        end
+      end
+    end
   
 end
 

data/lib/biomart/dataset.rb

@@ -64,9 +64,18 @@ module Biomart
     # optional arguments:
     #
     # :filters::         hash of key-value pairs (filter => search term)
+    # :timeout::         set a timeout length for the request (secs)
     def count( args={} )
-      args.merge!({ :count => "1" })
-      result = request( :method => 'post', :url => @url, :query => generate_xml(args) )
+      result = request(
+        :method  => 'post',
+        :url     => @url,
+        :timeout => args[:timeout],
+        :query   => generate_xml(
+          :filters    => args[:filters], 
+          :attributes => args[:attributes], 
+          :count      => "1"
+        )
+      )
       return result.to_i
     end
     
@@ -77,6 +86,7 @@ module Biomart
     # :filters::         hash of key-value pairs (filter => search term)
     # :attributes::      array of attributes to retrieve
     # :process_results:: true/false - convert search results to object
+    # :timeout::         set a timeout length for the request (secs)
     #
     # By default will return a hash with the following:
     # 
@@ -86,9 +96,17 @@ module Biomart
     # But with the :process_results option will return an array of hashes, 
     # where each hash represents a row of results (keyed by the attribute name).
     def search( args={} )
-      response = request( :method => 'post', :url => @url, :query => generate_xml(args) )
-      result   = process_tsv( args, response )
-      result   = conv_results_to_a_of_h( result ) if args[:process_results]
+      response = request(
+        :method  => 'post',
+        :url     => @url,
+        :timeout => args[:timeout],
+        :query   => generate_xml(
+          :filters    => args[:filters],
+          :attributes => args[:attributes]
+        )
+      )
+      result = process_tsv( args, response )
+      result = conv_results_to_a_of_h( result ) if args[:process_results]
       return result
     end
     

data/tasks/metrics.task

@@ -0,0 +1,23 @@
+begin
+  require "metric_fu"
+  MetricFu::Configuration.run do |config| 
+    config.metrics  = [:churn, :saikuro, :flog, :flay, :reek, :roodi, :rcov]
+    config.graphs   = [:flog, :flay, :reek, :roodi, :rcov]
+    config.flog     = { :dirs_to_flog  => ["lib"] }
+    config.flay     = { :dirs_to_flay  => ["lib"] }
+    config.reek     = { :dirs_to_reek  => ["lib"] }
+    config.roodi    = { :dirs_to_roodi => ["lib"] }
+    config.rcov     = { 
+                        :test_files => ["test/test_*.rb"],
+                        :rcov_opts  => [
+                          "--sort coverage", 
+                          "--no-html", 
+                          "--text-coverage",
+                          "--no-color",
+                          "--profile",
+                          "--exclude /gems/,/Library/,spec,features"
+                        ]
+                      }
+  end
+rescue LoadError
+end

data/test/test_biomart.rb

@@ -42,7 +42,7 @@ class BiomartTest < Test::Unit::TestCase
     setup do
       @htgt_targ = @htgt.datasets["htgt_targ"]
       @htgt_trap = @htgt.datasets["htgt_trap"]
-      @kermits = @htgt.datasets["kermits"]
+      @kermits   = @htgt.datasets["kermits"]
     end
     
     should "have basic metadata" do
@@ -63,34 +63,31 @@ class BiomartTest < Test::Unit::TestCase
       assert( @kermits.attributes["ensembl_gene_id"].is_a?( Biomart::Attribute ), "Biomart::Dataset is not creating Biomart::Attribute objects." )
     end
     
-    should "perform count queries" do
-      htgt_count = @htgt_targ.count()
-      assert( htgt_count.is_a?( Integer ), "Biomart::Dataset.count is not returning integers." )
-      assert( htgt_count > 0, "Biomart::Dataset.count is returning zero - this is wrong!" )
+    should "perform count/search queries" do
+      perform_count_queries("net/http")
+      perform_search_queries("net/http")
       
-      htgt_count_single_filter = @htgt_targ.count( :filters => { "is_eucomm" => "1" } )
-      assert( htgt_count_single_filter.is_a?( Integer ), "Biomart::Dataset.count (with single filter) is not returning integers." )
-      assert( htgt_count_single_filter > 0, "Biomart::Dataset.count (with single filter) is returning zero - this is wrong!" )
-      
-      htgt_count_single_filter_group_value = @htgt_targ.count( :filters => { "marker_symbol" => ["Cbx1","Cbx7","Art4"] } )
-      assert( htgt_count_single_filter_group_value.is_a?( Integer ), "Biomart::Dataset.count (with single filter, group value) is not returning integers." )
-      assert( htgt_count_single_filter_group_value > 0, "Biomart::Dataset.count (with single filter, group value) is returning zero - this is wrong!" )
+      #if CURB_AVAILABLE
+      #  perform_count_queries("curb")
+      #  perform_search_queries("curb")
+      #  Biomart.use_net_http = true
+      #  perform_count_queries("net/http")
+      #  perform_search_queries("net/http")
+      #else
+      #  perform_count_queries("net/http")
+      #  perform_search_queries("net/http")
+      #end
     end
     
-    should "perform search queries" do
-      search = @htgt_trap.search()
-      assert( search.is_a?( Hash ), "Biomart::Dataset.search (no options) is not returning a hash." )
-      assert( search[:data].is_a?( Array ), "Biomart::Dataset.search[:data] (no options) is not returning an array." )
+    should "perform search queries whilst altering the timeout property" do
+      search = @htgt_trap.search( :timeout => 60 )
+      assert( search.is_a?( Hash ), "Biomart::Dataset.search (no options except per-request timeout) is not returning a hash." )
+      assert( search[:data].is_a?( Array ), "Biomart::Dataset.search[:data] (no options except per-request timeout) is not returning an array." )
       
-      search1 = @htgt_targ.search( :filters => { "marker_symbol" => "Cbx1" }, :process_results => true )
-      assert( search1.is_a?( Array ), "Biomart::Dataset.search (filters defined with processing) is not returning an array." )
-      assert( search1.first.is_a?( Hash ), "Biomart::Dataset.search (filters defined with processing) is not returning an array of hashes." )
-      assert( search1.first["marker_symbol"] == "Cbx1", "Biomart::Dataset.search (filters defined with processing) is not returning the correct info." )
-      
-      search2 = @htgt_targ.search( :filters => { "marker_symbol" => "Cbx1" }, :attributes => ["marker_symbol","ensembl_gene_id"], :process_results => true )
-      assert( search2.is_a?( Array ), "Biomart::Dataset.search (filters and attributes defined with processing) is not returning an array." )
-      assert( search2.first.is_a?( Hash ), "Biomart::Dataset.search (filters and attributes defined with processing) is not returning an array of hashes." )
-      assert( search2.first["marker_symbol"] == "Cbx1", "Biomart::Dataset.search (filters and attributes defined with processing) is not returning the correct info." )
+      Biomart.timeout = 60
+      search = @htgt_trap.search()
+      assert( search.is_a?( Hash ), "Biomart::Dataset.search (no options except global timeout) is not returning a hash." )
+      assert( search[:data].is_a?( Array ), "Biomart::Dataset.search[:data] (no options except global timeout) is not returning an array." )
     end
     
     should "handle search queries that will generate poorly formatted TSV data" do
@@ -100,17 +97,49 @@ class BiomartTest < Test::Unit::TestCase
           "is_eucomm", "is_komp_csd", "is_komp_regeneron", "is_norcomm",
           "is_mgp", "mgi_accession_id", "marker_symbol", "ensembl_gene_id",
           "status", "status_code", "status_type", "status_description",
-          "status_sequence", "pipeline_stage", "htgt_project_id", "bac",
+          "status_sequence", "pipeline_stage", "ikmc_project_id", "bac",
           "design_id", "design_plate", "design_well", "intvec_plate",
           "intvec_well", "intvec_distribute", "targvec_plate", "targvec_well",
           "targvec_distribute", "backbone", "cassette", "allele_name",
-          "escell_clone_name", "escell_distribute", "es_cell_line", "colonies_picked",
-          "is_latest_for_gene", "is_targeted_non_cond"
+          "escell_clone", "escell_distribute", "escell_line", "colonies_picked",
+          "is_latest_for_gene", "targeted_trap"
         ]
       )
       assert( search.is_a?( Hash ), "Biomart::Dataset.search (no options) is not returning a hash." )
       assert( search[:data].is_a?( Array ), "Biomart::Dataset.search[:data] (no options) is not returning an array." )
+      assert( search[:data].size > 0, "Biomart::Dataset.search[:data] for poorly formatted TSV data is empty." )
     end
+    
+  end
+  
+  def perform_count_queries( library )
+    htgt_count = @htgt_targ.count()
+    assert( htgt_count.is_a?( Integer ), "Biomart::Dataset.count is not returning integers. [using #{library} for HTTP communication]" )
+    assert( htgt_count > 0, "Biomart::Dataset.count is returning zero - this is wrong! [using #{library} for HTTP communication]" )
+    
+    htgt_count_single_filter = @htgt_targ.count( :filters => { "is_eucomm" => "1" } )
+    assert( htgt_count_single_filter.is_a?( Integer ), "Biomart::Dataset.count (with single filter) is not returning integers. [using #{library} for HTTP communication]" )
+    assert( htgt_count_single_filter > 0, "Biomart::Dataset.count (with single filter) is returning zero - this is wrong! [using #{library} for HTTP communication]" )
+    
+    htgt_count_single_filter_group_value = @htgt_targ.count( :filters => { "marker_symbol" => ["Cbx1","Cbx7","Art4"] } )
+    assert( htgt_count_single_filter_group_value.is_a?( Integer ), "Biomart::Dataset.count (with single filter, group value) is not returning integers. [using #{library} for HTTP communication]" )
+    assert( htgt_count_single_filter_group_value > 0, "Biomart::Dataset.count (with single filter, group value) is returning zero - this is wrong! [using #{library} for HTTP communication]" )
+  end
+  
+  def perform_search_queries( library )
+    search = @htgt_trap.search()
+    assert( search.is_a?( Hash ), "Biomart::Dataset.search (no options) is not returning a hash. [using #{library} for HTTP communication]" )
+    assert( search[:data].is_a?( Array ), "Biomart::Dataset.search[:data] (no options) is not returning an array. [using #{library} for HTTP communication]" )
+    
+    search1 = @htgt_targ.search( :filters => { "marker_symbol" => "Cbx1" }, :process_results => true )
+    assert( search1.is_a?( Array ), "Biomart::Dataset.search (filters defined with processing) is not returning an array. [using #{library} for HTTP communication]" )
+    assert( search1.first.is_a?( Hash ), "Biomart::Dataset.search (filters defined with processing) is not returning an array of hashes. [using #{library} for HTTP communication]" )
+    assert( search1.first["marker_symbol"] == "Cbx1", "Biomart::Dataset.search (filters defined with processing) is not returning the correct info. [using #{library} for HTTP communication]" )
+    
+    search2 = @htgt_targ.search( :filters => { "marker_symbol" => "Cbx1" }, :attributes => ["marker_symbol","ensembl_gene_id"], :process_results => true )
+    assert( search2.is_a?( Array ), "Biomart::Dataset.search (filters and attributes defined with processing) is not returning an array. [using #{library} for HTTP communication]" )
+    assert( search2.first.is_a?( Hash ), "Biomart::Dataset.search (filters and attributes defined with processing) is not returning an array of hashes. [using #{library} for HTTP communication]" )
+    assert( search2.first["marker_symbol"] == "Cbx1", "Biomart::Dataset.search (filters and attributes defined with processing) is not returning the correct info. [using #{library} for HTTP communication]" )
   end
   
   context "The Biomart module" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: biomart
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors: 
 - Darren Oakley
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-30 00:00:00 +00:00
+date: 2010-01-20 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -68,7 +68,8 @@ files:
 - script/console
 - script/destroy
 - script/generate
-- tasks/shoulda.rake
+- tasks/metrics.task
+- tasks/shoulda.task
 - test/test_biomart.rb
 - test/test_helper.rb
 has_rdoc: true