intermine 0.98.08 → 0.98.09

data/Rakefile

@@ -52,17 +52,10 @@ end
 
 Rake::TestTask.new(:live_tests) do |t|
     t.libs << "test"
-    t.test_files = FileList['test/live_test.rb'] << FileList['test/live_summary_test.rb']
+    t.test_files = FileList['test/live_test.rb'] << FileList['test/live_summary_test.rb'] << FileList['test/live_results.rb']
     t.verbose = true
 end
 
-Rake::TestTask.new(:live_summary) do |t|
-    t.libs << "test"
-    t.test_files = FileList['test/live_summary_test.rb']
-    t.verbose = true
-end
-
-
 Rake::RDocTask.new do |t|
     t.title = 'InterMine Webservice Client Documentation'
     t.rdoc_files.include 'README.rdoc'

data/lib/intermine/query.rb

@@ -430,6 +430,9 @@ module InterMine::PathQuery
         #     puts r.to_h # Materialize the row an a Hash
         #   end
         #
+        # This method is now deprecated and will be removed in version 1
+        # Please use Query#rows
+        #
         def each_row(start=nil, size=nil)
             start = start.nil? ? @start : start
             size  = size.nil? ? @size : size
@@ -447,6 +450,9 @@ module InterMine::PathQuery
         #     end
         #   end
         #
+        # This method is now deprecated and will be removed in version 1
+        # Please use Query#results
+        #
         def each_result(start=nil, size=nil)
             start = start.nil? ? @start : start
             size  = size.nil? ? @size : size
@@ -462,7 +468,7 @@ module InterMine::PathQuery
             return results_reader.get_size
         end
 
-        # Returns an Array of ResultRow objects containing the 
+        # Returns an Enumerable of ResultRow objects containing the 
         # data returned by running this query, starting at the given offset and 
         # containing up to the given maximum size.
         #
@@ -477,15 +483,12 @@ module InterMine::PathQuery
         def rows(start=nil, size=nil)
             start = start.nil? ? @start : start
             size  = size.nil? ? @size : size
-            res = []
-            results_reader(start, size).each_row {|row|
-                res << row
-            }
-            res
+            return Results::RowReader.new(@url, self, start, size)
         end
 
         # Return objects corresponding to the type of data requested, starting 
-        # at the given row offset.
+        # at the given row offset. Returns an Enumerable of InterMineObject,
+        # where each value is read one at a time from the connection. 
         #
         #  genes = query.results
         #  genes.last.symbol
@@ -494,47 +497,49 @@ module InterMine::PathQuery
         def results(start=nil, size=nil)
             start = start.nil? ? @start : start
             size  = size.nil? ? @size : size
-            res = []
-            results_reader(start, size).each_result {|row|
-                res << row
-            }
-            res
+            return Results::ObjectReader.new(@url, self, start, size)
         end
 
-        def summary_items(summary_path, start=0, size=nil)
+        # Return an Enumerable of summary items starting at the given offset.
+        #
+        #  summary = query.summary_items("chromosome.primaryIdentifier")
+        #  top_chromosome = summary[0]["item"]
+        #  no_in_top_chrom = summary[0]["count"]
+        #
+        # This can be made more efficient by passing in a size - ie, if 
+        # you only want the top item, pass in an offset of 0 and a size of 1
+        # and only that row will be fetched.
+        #
+        def summaries(path, start=0, size=nil)
             q = self.clone
-            q.add_views(summary_path)
-            rr = q.results_reader(start, size)
-            if block_given?
-                rr.each_summary(summary_path) {|summary|
-                    yield summary
-                }
-            else
-                ret  = []
-                rr.each_summary(summary_path) {|summary|
-                    ret << summary
-                }
-                return ret
-            end
+            q.add_views(path)
+            return Results::SummaryReader.new(@url, q, start, size, path)
         end
 
-        def summarise(summary_path, start=0, size=nil)
-            path = make_path(add_prefix(summary_path))
-            q = self.clone
-            q.add_views(summary_path)
-            rr = q.results_reader(start, size)
-            if InterMine::Metadata::Model::NUMERIC_TYPES.include? path.end_type
-                h = {}
-                rr.each_summary(summary_path) { |summary|
-                    h = Hash[summary.map {|k, v| [k, v.to_f]}]
-                }
-                return h
+        # Return a summary for a column as a Hash
+        #
+        # For numeric values the hash has four keys: "average", "stdev", "min", and "max". 
+        #
+        #  summary = query.summarise("length")
+        #  puts summary["average"]
+        #
+        # For non-numeric values, the hash will have each possible value as a key, and the
+        # count of the occurrences of that value in this query's result set as the 
+        # corresponding value:
+        # 
+        #  summary = query.summarise("chromosome.primaryIdentifier")
+        #  puts summary["2L"]
+        #
+        # To limit the size of the result set you can use start and size as per normal 
+        # queries - this has no real effect with numeric queries, which always return the 
+        # same information.
+        #
+        def summarise(path, start=0, size=nil)
+            t = make_path(add_prefix(path)).end_type
+            if InterMine::Metadata::Model::NUMERIC_TYPES.include? t
+                return Hash[summaries(path, start, size).first.map {|k, v| [k, v.to_f]}]
             else
-                h = {}
-                rr.each_summary(summary_path) {|summary|
-                    h[summary["item"]] = summary["count"]
-                }
-                return h
+                return Hash[summaries(path, start, size).map {|sum| [sum["item"], sum["count"]]}]
             end
         end
 
@@ -1639,21 +1644,96 @@ module InterMine::PathQuery
             return p
         end
 
+        # Returns an Enumerable of ResultRow objects containing the 
+        # data returned by running this query, starting at the given offset and 
+        # containing up to the given maximum size.
+        #
+        # The webservice enforces a maximum page-size of 10,000,000 rows,
+        # independent of any size you specify - this can be obviated with paging
+        # for large result sets.
+        #
+        #   names = template.rows("A" => "eve").map {|r| r["name"]}
+        #
+        def rows(params = {}, start=0, size=nil)
+            runner = (params.empty?) ? self : get_adjusted(params)
+            return self.class.superclass.instance_method(:rows).bind(runner).call(start, size)
+        end
+
         def each_row(params = {}, start=0, size=nil)
             runner = (params.empty?) ? self : get_adjusted(params)
             runner.results_reader(start, size).each_row {|r| yield r}
         end
 
+        # Return objects corresponding to the type of data requested, starting 
+        # at the given row offset. Returns an Enumerable of InterMineObject,
+        # where each value is read one at a time from the connection. 
+        #
+        #  template.results("A" => "eve").each {|gene|
+        #      puts gene.symbol
+        #  }
+        #
+        def results(params = {}, start=0, size=nil)
+            runner = (params.empty?) ? self : get_adjusted(params)
+            return self.class.superclass.instance_method(:results).bind(runner).call(start, size)
+        end
+
         def each_result(params = {}, start=0, size=nil) 
             runner = (params.empty?) ? self : get_adjusted(params)
             runner.results_reader(start, size).each_result {|r| yield r}
         end
 
+        # Return an Enumerable of summary items starting at the given offset.
+        #
+        #  summary = template.summary_items("chromosome.primaryIdentifier", {"A" => "Pentose Phosphate Pathway"})
+        #  top_chromosome = summary[0]["item"]
+        #  no_in_top_chrom = summary[0]["count"]
+        #
+        # This can be made more efficient by passing in a size - ie, if 
+        # you only want the top item, pass in an offset of 0 and a size of 1
+        # and only that row will be fetched.
+        #
+        def summaries(path, params = {}, start=0, size=nil)
+            runner = (params.empty?) ? self : get_adjusted(params)
+            return self.class.superclass.instance_method(:summaries).bind(runner).call(path, start, size)
+        end
+
+        # Return a summary for a column as a Hash
+        #
+        # For numeric values the hash has four keys: "average", "stdev", "min", and "max". 
+        #
+        #  summary = template.summarise("length", {"A" => "eve"})
+        #  puts summary["average"]
+        #
+        # For non-numeric values, the hash will have each possible value as a key, and the
+        # count of the occurrences of that value in this query's result set as the 
+        # corresponding value:
+        # 
+        #  summary = template.summarise("chromosome.primaryIdentifier", {"A" => "eve"})
+        #  puts summary["2L"]
+        #
+        # To limit the size of the result set you can use start and size as per normal 
+        # queries - this has no real effect with numeric queries, which always return the 
+        # same information.
+        #
+        def summarise(path, params={}, start=0, size=nil)
+            t = make_path(add_prefix(path)).end_type
+            if InterMine::Metadata::Model::NUMERIC_TYPES.include? t
+                return Hash[summaries(path, params, start, size).first.map {|k, v| [k, v.to_f]}]
+            else
+                return Hash[summaries(path, params, start, size).map {|sum| [sum["item"], sum["count"]]}]
+            end
+        end
+
+        # Return the number of result rows this query will return in its current state. 
+        # This makes a very small request to the webservice, and is the most efficient 
+        # method of getting the size of the result set.
         def count(params = {})
             runner = (params.empty?) ? self : get_adjusted(params)
             runner.results_reader.get_size
         end
 
+        # Return a clone of the current template. Changes made to the clone will not effect
+        # the cloned query.
         def clone
             other = super
             other.instance_variable_set(:@constraints, @constraints.map {|c| c.clone})

data/lib/intermine/results.rb

@@ -209,7 +209,6 @@ module InterMine::Results
         end
     end
 
-
     # The class responsible for retrieving results and processing them
     #
     #   query.each_row do |row|
@@ -251,7 +250,10 @@ module InterMine::Results
 
         # Iterate over the result set one ResultsRow at a time
         def each_row
-            processor = lambda {|x| ResultsRow.new(x.chomp("," + $/), @query.views) }
+            processor = lambda {|line|
+                x = line.chomp.chomp(",")
+                x.empty? ? nil : ResultsRow.new(x, @query.views)
+            }
             read_result_set(params("jsonrows"), processor) {|x|
                 yield x
             }
@@ -274,7 +276,10 @@ module InterMine::Results
         #
         def each_result
             model = @query.model
-            processor = lambda {|x| model.make_new(JSON.parse(x.chomp("," + $/)))}
+            processor = lambda {|line|
+                x = line.chomp.chomp(",")
+                x.empty? ? nil : model.make_new(JSON.parse(x))
+            }
             read_result_set(params("jsonobjects"), processor) {|x|
                 yield x
             }
@@ -283,7 +288,10 @@ module InterMine::Results
         def each_summary(summary_path)
             extra = {"summaryPath" => @query.add_prefix(summary_path)}
             p = params("jsonrows").merge(extra)
-            processor = lambda {|x| JSON.parse(x.chomp("," + $/)) }
+            processor = lambda {|line|
+                x = line.chomp.chomp(",")
+                x.empty? ? nil : JSON.parse(x)
+            }
             read_result_set(p, processor) {|x|
                 yield x
             }
@@ -300,9 +308,11 @@ module InterMine::Results
                     begin
                         row = processor.call(line)
                     rescue => e
-                        raise ServiceError, "Error parsing #{line}: #{e.message}"
+                        raise ServiceError, "Error parsing '#{line}': #{e.message}"
+                    end
+                    unless row.nil?
+                        yield row
                     end
-                    yield row
                 else
                     container << line
                     if line.chomp($/).end_with?("[")
@@ -330,7 +340,9 @@ module InterMine::Results
                             if sock.eof?
                                 holdover = line
                             else
-                                yield line
+                                unless line.empty?
+                                    yield line
+                                end
                             end
                         }
                         sock.close
@@ -363,6 +375,35 @@ module InterMine::Results
         end
     end
 
+    class RowReader < ResultsReader
+
+        include Enumerable
+
+        alias :each :each_row
+    end
+
+    class ObjectReader < ResultsReader
+
+        include Enumerable
+
+        alias :each :each_result
+
+    end
+
+    class SummaryReader < ResultsReader
+
+        include Enumerable
+
+        def initialize(uri, query, start, size, path)
+            super(uri, query, start, size)
+            @path = path
+        end
+
+        def each
+            each_summary(@path) {|x| yield x}
+        end
+    end
+
     # Errors if there are problems retrieving results from the webservice.
     class ServiceError < RuntimeError
     end

data/lib/intermine/version.rb

@@ -1,3 +1,9 @@
 module Intermine
-  VERSION = "0.98.08"
+
+    # Webservice Client Version number
+    #
+    # Changes:
+    #   0.98.09 - Major changes to results - now with thorough-going Enumerable support
+    #   0.98.08 - Added column summary support
+    VERSION = "0.98.09"
 end

data/test/live_test.rb

@@ -6,7 +6,7 @@ require "intermine/service"
 class LiveDemoTest <  Test::Unit::TestCase
 
     def setup
-        @service = Service.new("http://localhost:8080/intermine-test")
+        @service = Service.new("http://localhost/intermine-test", "Z1a3D3U16cicCdS0T6y4bdN1SQh")
     end
 
     def testVersion
@@ -22,35 +22,15 @@ class LiveDemoTest <  Test::Unit::TestCase
         assert_equal(3, @service.query("Department").where(:name => "Sales").count)
     end
 
-end
-
-class LiveFlyMineTest < Test::Unit::TestCase
-
-    def setup
-        @service = Service.new("www.flymine.org/query")
+    def testGetTemplate
+        template = @service.template("ManagerLookup")
+        assert_equal("ManagerLookup", template.name)
+        assert_equal(1, template.constraints.length)
     end
 
-    # Tests a number of integrated features:
-    #  * Getting a template
-    #  * Passing template parameters
-    #  * getting counts
-    #  * getting rows
-    #  * getting records
-    #
-    def testBigResultSet
-        template = @service.template("Chromosome_Gene")
-        args = {"A" => {"!=" => '2L'}}
-        size = template.count(args)
-        i = 0
-        template.each_row(args) do |r|
-            i += 1
-        end
-        assert_equal(size, i)
-        i = 0
-        template.each_result(args) do |r|
-            i += 1
-        end
-        assert_equal(size, i)
+    def testGetLists
+        list = @service.list("My-Favourite-Employees")
+        assert_equal(4, list.size)
     end
-end
 
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: intermine
 version: !ruby/object:Gem::Version 
-  hash: 391
+  hash: 389
   prerelease: false
   segments: 
   - 0
   - 98
-  - 8
-  version: 0.98.08
+  - 9
+  version: 0.98.09
 platform: ruby
 authors: 
 - Alex Kalderimis