intermine 0.99.03 → 1.00.00

data/Rakefile

@@ -1,14 +1,14 @@
 require 'rubygems'
 require 'rubygems/specification' unless defined?(Gem::Specification)
+require 'rubygems/package_task'
 require 'rake/testtask'
-require 'rake/gempackagetask'
 
-gem 'rdoc', '=2.1.0'
-require 'rdoc/rdoc'
-require 'rake/rdoctask'
-
-gem 'darkfish-rdoc'
-require 'darkfish-rdoc'
+#gem 'rdoc'# , '=2.1.0'
+#require 'rdoc/rdoc'
+#require 'rake/rdoctask'
+#
+#gem 'darkfish-rdoc'
+#require 'darkfish-rdoc'
 
 def gemspec
     @gemspec ||= begin
@@ -38,30 +38,44 @@ task :release => :package do
       sh "gem push pkg/#{gemspec.name}-#{gemspec.version}.gem"
 end
 
-Rake::GemPackageTask.new(gemspec) do |pkg|
+Gem::PackageTask.new(gemspec) do |pkg|
     pkg.need_zip = true
     pkg.need_tar = true
-
 end
 
-Rake::TestTask.new do |t|
-    t.libs << "test"
-    t.test_files = FileList['test/unit_tests.rb']
-    t.verbose = true
-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'] << FileList['test/live_results.rb']
-    t.verbose = true
-end
 
-Rake::RDocTask.new do |t|
-    t.title = 'InterMine Webservice Client Documentation'
-    t.rdoc_files.include 'README.rdoc'
-    t.rdoc_files.include 'lib/**/*rb'
-    t.main = 'README.rdoc'
-    t.options += ['-SHN', '-f', 'darkfish']
+namespace :test do
+
+    desc "Run the unit-tests"
+    Rake::TestTask.new(:unit) do |t|
+        t.libs << "test"
+        t.test_files = FileList['test/unit_tests.rb']
+        t.verbose = true
+        puts "Running UNIT TESTS"
+    end
+
+    desc "Run the live integration tests"
+    Rake::TestTask.new(:live) do |t|
+        t.libs << "test"
+        t.test_files = FileList['test/live_test.rb'] << FileList['test/live_summary_test.rb'] << FileList['test/live_results.rb']
+        t.verbose = false
+        puts "Running LIVE INTEGRATION TESTS"
+    end
+
+    desc "Run all tests"
+    task :all => [:unit, :live]
 end
 
+desc "Run the default test-suite"
+task :test => ["test:all"]
+
+#Rake::RDocTask.new do |t|
+#    t.title = 'InterMine Webservice Client Documentation'
+#    t.rdoc_files.include 'README.rdoc'
+#    t.rdoc_files.include 'lib/**/*rb'
+#    t.main = 'README.rdoc'
+#    t.options += ['-SHN', '-f', 'darkfish']
+#end
+
 

data/lib/intermine/lists.rb

@@ -312,6 +312,54 @@ module InterMine::Lists
             @tags = @manager.tags_for(self)
         end
 
+        ENRICHMENT_DEFAULTS = {:correction => "Holm-Bonferroni", :maxp => 0.05}
+
+        # Retrieve the results of an enrichment calculation
+        #
+        # Get the results of an enrichment calculate_enrichment with the default parameter values:
+        #
+        #  calculate_enrichment(widget)
+        #
+        # Pass optional parameters to the enrichment service:
+        #
+        #  calculate_enrichment(widget, :correction => "Benjamini-Hochberg", :maxp => 0.1)
+        #
+        # The optional parameters are: :correction, :maxp, :filter
+        #
+        # Each result returned by the enrichment service is a hash with the following
+        # keys: "p-value", "identifier", "matches", "description". The Hash returned also allows
+        # key access with symbols.
+        #
+        def calculate_enrichment(widget, opts = {})
+            s = @manager.service
+            params = s.params.merge(ENRICHMENT_DEFAULTS).merge(opts).merge(:widget => widget, :list => @name)
+            uri = URI.parse(s.root + Service::LIST_ENRICHMENT_PATH)
+            res = Net::HTTP.post_form(uri, params)
+            return case res
+            when Net::HTTPSuccess
+                JSON.parse(res.body)["results"].map {|row| SymbolAcceptingHash[row] }
+            else
+                begin
+                    container = JSON.parse(res.body)
+                    raise ServiceError, container["error"]
+                rescue
+                    res.error!
+                end
+            end
+        end
+
+        class SymbolAcceptingHash < Hash
+
+            def [](key)
+                return case key
+                when Symbol
+                    return super(key.to_s.gsub(/[_]/, '-'))
+                else
+                    return super(key)
+                end
+            end
+        end
+
         private
 
         # Used to interpret arguments to add and remove
@@ -675,10 +723,13 @@ module InterMine::Lists
         def make_list_names(objs)
             current_names = list_names
             return objs.map do |x|
-                case 
-                when x.is_a?(List)                   then x.name
-                when x.respond_to?(:list_upload_uri) then create_list(x).name
-                when current_names.include?(x.to_s)  then x.to_s
+                case x
+                when List
+                    x.name
+                when x.respond_to?(:list_upload_uri)
+                    create_list(x).name
+                when current_names.include?(x.to_s)
+                    x.to_s
                 else
                     raise ArgumentError, "#{x} is not a list you can access"
                 end
@@ -708,17 +759,15 @@ module InterMine::Lists
             else
                 begin
                     container = JSON.parse(response.body)
-                    err = container["error"]
+                    raise ServiceError, container["error"]
                 rescue
                     response.error!
                 end
-                raise ServiceError, container["error"]
             end
         end
 
         # Routine for creating a list from a PathQuery::Query
         def create_list_from_query(query, tags=[], name=nil, description=nil)
-            query = get_listable_query(query)
             uri = query.list_upload_uri
             list_params = {
                 "listName" => name,
@@ -730,19 +779,6 @@ module InterMine::Lists
             return Net::HTTP.post_form(URI.parse(uri), params)
         end
 
-        def get_listable_query(query)
-            clone = query.clone()
-            views = clone.views
-            selected_classes = views.map {|x| x.prefix}.uniq {|p| p.to_s}
-            if selected_classes.size == 1
-                return clone.select(selected_classes.first.append("id"))
-            elsif selected_classes.size == 0
-                return clone.select("#{clone.root.name}.id")
-            end
-            # Bound to fail, but let the service provide the message.
-            return clone
-        end
-
         # Routine for creating a List in a webservice from a list of Ids.
         def create_list_from_ids(ids, type, tags=[], name=nil, description=nil)
             if @service.model.get_cd(type).nil?

data/lib/intermine/model.rb

@@ -402,46 +402,6 @@ module Metadata
             return q
         end
 
-        # call-seq:
-        #   find(*attributes) => Enumerable[InterMineObject]
-        #
-        # Get the items in the database matching the identifiers.
-        #
-        #   zen = model.table("Gene").find("zen")
-        #   puts zen.length, zen.organism.name
-        #
-        # find may retrun multiple results:
-        # 
-        #   genes = model.table("Gene").find("zen", "eve", "r", "h")
-        #
-        # The search mechanism used is a "lookup" constraint, so extra-values
-        # may be provided to distinguish search terms by passing key-value pairs:
-        #
-        #   starting_with_c = model.table("Gene").find("c*" => "D. melanogaster")
-        #
-        def find(*attrs)
-            q = new_query
-            q.select("*")
-            attrs.each do |attr|
-                if attr.is_a? Hash
-                    attr.each do |term, extra|
-                        q.or(@root, "LOOKUP", term, extra)
-                    end
-                else
-                    q.or(@root, "LOOKUP", attr)
-                end
-            end
-
-            c = q.count()
-            if c < 1
-                raise ItemNotFoundError
-            elsif c == 1
-                return q.results.first
-            else
-                return q.results
-            end
-        end
-
         # call-seq: 
         #   where(*constraints) => PathQuery::Query
         #
@@ -487,8 +447,13 @@ module Metadata
         # attributes (ie. columns that can hold values, rather than references to 
         # other tables.)
         #
+        # The array returned will be sorted in alphabetical order by field-name.
+        #
         def attributes
-            return @fields.select {|k, v| v.is_a?(AttributeDescriptor)}.map {|pair| pair[1]}
+            return @fields.
+                select {|_, v| v.is_a?(AttributeDescriptor)}.
+                sort   {|(k0, _), (k1, _)| k0 <=> k1}.
+                map    {|(_, v)| v}
         end
 
         # Returns a human readable string
@@ -580,11 +545,8 @@ module Metadata
                         klass.class_eval do 
                             define_method(fd.name) do 
                                 if instance_variable_get("@" + fd.name).nil?
-                                    q = __cd__.select("id", fd.name + ".*").where(:id => objectId).outerjoin(fd.name)
-                                    instance_var = q.results.first.instance_variable_get('@' + fd.name)
-                                    if fd.is_a?(CollectionDescriptor) and instance_var.nil?
-                                        instance_var = []
-                                    end
+                                    q = __cd__.select(fd.name + ".*").where(:id => objectId)
+                                    instance_var = q.results.first[fd.name]
                                     instance_variable_set("@" + fd.name, instance_var)
                                 end
                                 return instance_variable_get("@" + fd.name)
@@ -614,16 +576,14 @@ module Metadata
                                 type = fd.referencedType
                                 if fd.is_a?(CollectionDescriptor)
                                     instance_var = []
-                                    if not val.nil?
-                                        val.each do |item|
-                                            if item.is_a?(Hash)
-                                                item = type.model.make_new(type.name, item)
-                                            end
-                                            if !item.is_a?(type)
-                                                raise ArgumentError, "Arguments to #{fd.name} in #{@name} must be #{type.name}s"
-                                            end
-                                            instance_var << item
+                                    val.each do |item|
+                                        if item.is_a?(Hash)
+                                            item = type.model.make_new(type.name, item)
                                         end
+                                        if !item.is_a?(type)
+                                            raise ArgumentError, "Arguments to #{fd.name} in #{@name} must be #{type.name}s"
+                                        end
+                                        instance_var << item
                                     end
                                     instance_variable_set("@" + fd.name, instance_var)
                                 else
@@ -794,55 +754,11 @@ module Metadata
             end
         end
 
-        # call-seq:
-        #   end => ClassDescriptor | ReferenceDescriptor | AttributeDescriptor
-        #
-        # Return the last element of this path
-        #
-        def end
-            return @elements.last
-        end
-
-        # call-seq:
-        #   prefix => Path
-        # 
-        # Return the Path one above this.
-        def prefix
-            if @elements.size == 1
-                raise PathException, "Root paths do not have a prefix"
-            end
-            new_str = @elements[0, @elements.size - 1].map {|x| x.name}.join(".")
-            return Path.new(new_str, @model, @subclasses)
-        end
-
-        # call-seq:
-        #   append(part, ...) => Path
-        #
-        # Return a new path by adding elements to this path.
-        #
-        def append(*parts)
-            new_str = self.to_s + "." + parts.join(".")
-            return Path.new(new_str, @model, @subclasses)
-        end
-
         # Two paths can be said to be equal when they stringify to the same representation.
         def ==(other)
             return self.to_s == other.to_s
         end
 
-        # Two paths are identical when they have the same everything.
-        def eql?(other)
-            begin
-                return (self == other) && @model.eql?(other.model) && @subclasses.eql?(other.subclasses)
-            rescue
-                return false
-            end
-        end
-
-        def hash
-            return 17 * @model.hash * 11 * @subclasses.hash * 3 * to_s.hash
-        end
-
         # Get the number of elements in the path
         def length
             return @elements.length
@@ -969,9 +885,6 @@ module Metadata
             end
         end
     end
-
-    class ItemNotFoundError < RuntimeError
-    end
 end
 end
 

data/lib/intermine/query.rb

@@ -616,10 +616,7 @@ module InterMine::PathQuery
                 if y.end_with?("*")
                     prefix = y.chomp(".*")
                     path = make_path(prefix)
-                    attrs = path.end_cd.attributes.map {|x| 
-                        prefix + "." + x.name
-                    }
-                    add_views(attrs)
+                    add_views(path.end_cd.attributes.map {|x| prefix + "." + x.name})
                 else
                     path = make_path(y)
                     path = make_path(y.to_s + ".id") unless path.is_attribute?
@@ -723,11 +720,8 @@ module InterMine::PathQuery
         #
         def add_sort_order(path, direction="ASC") 
             p = self.path(path)
-            selected = @views.map {|v| v.prefix}
-            selected.push(@constraints.map {|c| c.path.is_attribute? ? c.path.prefix : c.path })
-            selected.uniq!
-            if !selected.include? p.prefix
-                raise ArgumentError, "Sort order (#{p}) not on a selected class (#{selected.map {|v| v.to_s}.inspect} in #{self.name || 'unnamed query'})"
+            if !@views.include? p
+                raise ArgumentError, "Sort order (#{p}) not in view (#{@views.map {|v| v.to_s}.inspect} in #{self.name || 'unnamed query'})"
             end
             @sort_order << SortOrder.new(p, direction)
             return self
@@ -765,32 +759,6 @@ module InterMine::PathQuery
             @constraints << con
             return con
         end
-        
-        def or(*parameters)
-            logic = @logic
-            new_con = add_constraint(*parameters)
-
-            if logic
-                set_logic(LogicGroup.new(logic, "OR", new_con))
-            elsif @constraints.size > 1
-                set_logic(@constraints.map {|c| c.code }.join(" or "))
-            end
-
-            return self
-        end
-
-        def and(*parameters)
-            logic = @logic
-            new_con = add_constraint(*parameters)
-
-            if logic
-                set_logic(LogicGroup.new(logic, "AND", new_con))
-            elsif @constraints.size > 1
-                set_logic(@constraints.map {|c| c.code }.join(" and "))
-            end
-
-            return self
-        end
 
         # Returns a Path object constructed from the given path-string, 
         # taking the current state of the query into account (its data-model 
@@ -855,7 +823,7 @@ module InterMine::PathQuery
                                 end
                                 parameters[:values] = subv.to_a
                             elsif subv.is_a?(Lists::List)
-                                if subk == "=" or subk == "<" or subk == "<="
+                                if subk == "="
                                     parameters[:op] = "IN"
                                 elsif subk == "!="
                                     parameters[:op] = "NOT IN"
@@ -863,19 +831,6 @@ module InterMine::PathQuery
                                     parameters[:op] = normalised_k
                                 end
                                 parameters[:value] = subv.name
-                            elsif subv.is_a? Query
-                                if subk == "=" or subk == "<" or subk == "<="
-                                    parameters[:op] = "IN"
-                                elsif subk == "!="
-                                    parameters[:op] = "NOT IN"
-                                else
-                                    parameters[:op] = normalised_k
-                                end
-                                s = subv.service
-                                l = s.create_list(subv)
-
-                                parameters[:value] = l.name
-
                             else
                                 parameters[:op] = normalised_k
                                 parameters[:value] = subv
@@ -988,7 +943,7 @@ module InterMine::PathQuery
             @classes = [
                 SingleValueConstraint, 
                 SubClassConstraint, 
-                LookupConstraint, MultiValueConstraint, 
+                LookupConstraint, MultiValueConstraint, RangeConstraint,
                 UnaryConstraint, LoopConstraint, ListConstraint]
 
             @query = query
@@ -1014,14 +969,9 @@ module InterMine::PathQuery
 
             attr_keys = parameters.keys
             suitable_classes = @classes.select { |cls| 
-                is_suitable = true
-                attr_keys.each { |key| 
-                    is_suitable = is_suitable && (cls.method_defined?(key)) 
-                    if key.to_s == "op"
-                        is_suitable = is_suitable && cls.valid_ops.include?(parameters[key])
-                    end
-                }
-                is_suitable
+                attr_keys.reduce(true) do |suitable, k|
+                    suitable && cls.method_defined?(k) && (k.to_s != "op" or cls.valid_ops.include?(parameters[k]))
+                end
             }
             if suitable_classes.size > 1
                 raise ArgumentError, "More than one class found for #{parameters.inspect}"
@@ -1402,10 +1352,31 @@ module InterMine::PathQuery
         end
     end
 
+    class RangeConstraint < MultiValueConstraint
+
+        VALID_OPS = [
+            "WITHIN", "OUTSIDE",
+            "CONTAINS", "DOES NOT CONTAIN",
+            "OVERLAPS", "DOES NOT OVERLAP"
+        ]
+
+        def self.valid_ops
+            return VALID_OPS
+        end
+
+        def validate
+            # no-op
+        end
+    end
+
     class TemplateMultiValueConstraint < MultiValueConstraint 
         include TemplateConstraint
     end
 
+    class TemplateRangeConstraint < RangeConstraint
+        include TemplateConstraint
+    end
+
     class SortOrder 
         include PathFeature
         attr_accessor :direction

data/lib/intermine/results.rb

@@ -85,12 +85,12 @@ module InterMine::Results
         def [](arg, length=nil)
             unless length.nil?
                 raise ArgumentError, "when providing a length, the first argument must be an Integer" unless arg.is_a? Integer
-                return @results[arg, length].map {|x| value_of(x)}
+                return @results[arg, length].map {|x| x["value"]}
             end
 
             case arg
             when Range
-                return @results[arg].map {|x| value_of(x)}
+                return @results[arg].map {|x| x["value"]}
             when Integer
                 idx = arg
             else
@@ -101,19 +101,19 @@ module InterMine::Results
 
             cell = @results[idx]
 
-            raise IndexError, "Argument out of range" if @columns[idx].nil?
+            raise IndexError, "Argument out of range" if cell.nil?
 
-            return value_of(cell)
+            return cell["value"]
         end
 
         # Returns the first value in this row
         def first
-            return value_of(@results[0])
+            return @results[0]["value"]
         end
 
         # Returns the last value in this row
         def last
-            return value_of(@results.last)
+            return @results.last["value"]
         end
 
         # Iterate over the values in this row in the
@@ -134,11 +134,9 @@ module InterMine::Results
         def each(&block) 
             if block
                 if block.arity == 1
-                    @results.each {|x| block.call(value_of(x))}
+                    @results.each {|x| block.call(x["value"])}
                 else block.arity == 2
-                    (0 ... @results.size).to_a.each {|i| 
-                        block.call(@columns[i], value_of(@results[i]))
-                    }
+                    (0 ... @results.size).to_a.each {|i| block.call(@columns[i], @results[i]["value"])}
                 end
             end
             return self
@@ -156,7 +154,7 @@ module InterMine::Results
 
         # Return an Array version of the row.
         def to_a
-            return @results.map {|x| value_of(x)}
+            return @results.map {|x| x["value"]}
         end
 
         # Return a Hash version of the row. All keys in this
@@ -187,15 +185,11 @@ module InterMine::Results
         # CSV or TSV file. The optional separator argument will be used to delimit
         # columns
         def to_csv(sep="\t")
-            return @results.map {|x| value_of(x).inspect}.join(sep)
+            return @results.map {|x| x["value"].inspect}.join(sep)
         end
 
         private
 
-        def value_of(cell)
-            return cell["value"]
-        end
-
         # Return the index for a string or symbol key.
         def index_for(key)
             if @indexes.nil?
@@ -215,13 +209,6 @@ module InterMine::Results
         end
     end
 
-    class NewResultRow < ResultsRow
-
-        def value_of(cell)
-            return cell
-        end
-    end
-
     # The class responsible for retrieving results and processing them
     #
     #   query.each_row do |row|
@@ -263,13 +250,11 @@ module InterMine::Results
 
         # Iterate over the result set one ResultsRow at a time
         def each_row
-            cls = @query.service.version >= 8 ? NewResultRow : ResultsRow
-            format = @query.service.version >= 8 ? "json" : "jsonrows"
             processor = lambda {|line|
                 x = line.chomp.chomp(",")
-                x.empty? ? nil : cls.new(x, @query.views)
+                x.empty? ? nil : ResultsRow.new(x, @query.views)
             }
-            read_result_set(params(format), processor) {|x|
+            read_result_set(params("jsonrows"), processor) {|x|
                 yield x
             }
         end

data/lib/intermine/service.rb

@@ -109,6 +109,7 @@ module InterMine
         LIST_INTERSECTION_PATH = "/lists/intersect/json"
         LIST_SUBTRACTION_PATH = "/lists/subtract/json"
         LIST_TAG_PATH = "/list/tags/json"
+        LIST_ENRICHMENT_PATH = "/list/enrichment"
 
         # The webservice version. An integer that 
         # supplies information about what features are supported.

data/lib/intermine/version.rb

@@ -3,6 +3,9 @@ module Intermine
     # Webservice Client Version number
     #
     # Changes:
+    #   1.00.00 - Up to make use of new features of the InterMine 1.0 API
+    #             * Enrichment queries
+    #             * Range constraints
     #   0.98.11 - * InterMineObjects now lazily fetch their references 
     #             if nil. Note that while extremely convenient, 
     #             explicit prefetching will be much more efficient 
@@ -12,10 +15,5 @@ module Intermine
     #   0.98.10 - Added status property to lists
     #   0.98.09 - Major changes to results - now with thorough-going Enumerable support
     #   0.98.08 - Added column summary support
-    #   0.99.00 - Added coercion from query to lists in "IN/NOT IN" constraints
-    #           - Added support for "json" format (performance) improvement
-    #   0.99.01 - Added support for sort-orders on selected classes which are not in the view
-    #   0.99.02 - Fixed bug with null values in new result rows (resulting commonly from outer joins)
-    #   0.99.03 - Fixed handling of null references and empty collections in lazy reference fetching.
-    VERSION = "0.99.03"
+    VERSION = "1.00.00"
 end

data/test/live_results.rb

@@ -0,0 +1,164 @@
+require File.dirname(__FILE__) + "/test_helper.rb"
+
+require "test/unit"
+require "intermine/service"
+require "intermine/results"
+
+class LiveResultsTest < Test::Unit::TestCase
+
+    def setup
+        @service = Service.new("http://localhost/intermine-test")
+        @max = 50
+        @q = @service.query("Employee").select("*", "department.*").where(:age => {:lt => @max})
+        @empty = @service.query("Employee").where(:name => "some-non-existant-value")
+        @exp_count = 82
+        @expected_last = "Didier Legu\303\251lec"
+        @expected_last_summary = "Vincent"
+        @expected_last_obj = "Both Quotes '\""
+        @expected_target = 37.02439
+        @expected_two_vowels = 31
+        @exp_trideps = 5
+        @exp_s_deps = 29
+        @exp_row_size = 7
+        @rows_args = []
+        @results_args = []
+        @summary_args = []
+        @count_args = []
+        @dep_size = 3
+    end
+
+    def testRowIteration
+        count = 0
+        @q.rows(*@rows_args).each do |row|
+            assert_equal(@exp_row_size, row.size)
+            assert(row["age"].is_a? Fixnum)
+            assert(row["age"] < @max)
+            assert(row["name"].is_a? String)
+            count += 1
+        end
+        assert_equal(@exp_count, count)
+    end
+
+    def testEmptyRows
+        count = 0
+        @empty.rows.each do
+            count += 1
+        end
+        assert_equal(0, count)
+    end
+
+    def testRowMapping
+        names = @q.rows(*@rows_args).map {|r| r["name"]}
+        assert_equal(@exp_count, names.length)
+        assert_equal(@expected_last, names.last)
+    end
+
+    def testRowFolding
+        average = @q.rows(*@rows_args).reduce(0.0) {|m, i| m + i["age"]} / @q.count(*@count_args)
+        target = @expected_target
+        assert(average > target * 0.999999)
+        assert(average < target * 1.000001)
+    end
+        
+    def testRowFiltering
+        two_vowels = @q.rows(*@rows_args).select {|r| r["name"].match(/[aeiou]{2}/) }
+        assert_equal(@expected_two_vowels, two_vowels.length)
+    end
+
+    def testObjectIteration
+        count = 0
+        @q.results(*@results_args).each do |emp|
+            assert(emp.is_a? @q.model.table("Employee"))
+            assert(emp.age.is_a? Fixnum)
+            assert(emp.age < @max)
+            assert(emp.name.is_a? String)
+            count += 1
+        end
+        assert_equal(@exp_count, count)
+    end
+
+    def testEmptyObjects
+        count = 0
+        @empty.results.each do
+            count += 1
+        end
+        assert_equal(0, count)
+    end
+
+    def testObjectMapping
+        names = @q.results(*@results_args).map {|r| r.name}
+        assert_equal(@exp_count, names.length)
+        assert_equal(@expected_last_obj, names.last)
+    end
+
+    def testObjectFolding
+        average = @q.results(*@results_args).reduce(0.0) {|m, i| m + i.age} / @q.count(*@count_args)
+        target = @expected_target
+        assert(average > target * 0.999999, "Checking lower bound on #{average}")
+        assert(average < target * 1.000001, "Checking upper bound on #{average}")
+    end
+        
+    def testObjectFiltering
+        emps_in_s_deps = @q.results(*@results_args).select {|o| o.department.name.start_with? "S"}
+        assert_equal(@exp_s_deps, emps_in_s_deps.length)
+    end
+
+    def testSummaryIteration
+        count = 0
+        @q.summaries("name", *@summary_args).each do |summary|
+            assert_equal(1, summary["count"])
+            count += 1
+        end
+        assert_equal(@exp_count, count)
+    end
+
+    def testEmptySummaries
+        count = 0
+        @empty.summaries("name").each do
+            count += 1
+        end
+        assert_equal(0, count)
+    end
+
+    def testSummaryMapping
+        names = @q.summaries("name", *@summary_args).map {|s| s["item"]}
+        assert_equal(@exp_count, names.length)
+        assert_equal(@expected_last_summary, names.last)
+    end
+
+    def testSummaryFolding
+        sum = @q.summaries("name", *@summary_args).reduce(0) {|m, i| m + i["count"]}
+        assert_equal(@q.count(*@count_args), sum)
+    end
+        
+    def testSummaryFiltering
+        trideps = @q.summaries("department.name", *@summary_args).select {|s| s["count"] == @dep_size}
+        assert_equal(@exp_trideps, trideps.length)
+    end
+end
+
+class LiveTemplateResultsTest < LiveResultsTest 
+
+    def setup
+        @service = Service.new("http://localhost/intermine-test")
+        @q = @service.template("employeesOverACertainAgeFromDepartmentA")
+        @empty = @q
+        @exp_count = 18
+        @expected_last = "Tim Canterbury"
+        @expected_last_summary = "Tim Canterbury"
+        @expected_last_obj = "Fatou"
+        @expected_target = 47.277778
+        @expected_two_vowels = 4
+        @dep_size = 18
+        @exp_trideps = 1
+        @exp_s_deps = 18
+        @max = 69
+        @rows_args = [{"B" => "Sales"}]
+        @results_args = [{"B" => "Sales"}]
+        @summary_args = [{"B" => "Sales"}]
+        @count_args = [{"B" => "Sales"}]
+        @exp_row_size = 3
+
+    end
+end
+

data/test/live_summary_test.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + "/test_helper.rb"
+
+require "test/unit"
+require "intermine/service"
+
+class LiveSummaryTest < Test::Unit::TestCase
+
+    def setup
+        @service = Service.new("http://localhost/intermine-test")
+        @query = @service.query("Employee").where(:age => {:lt => 50})
+    end
+
+    def testIteration
+        @query.summaries("age").each {|summary|
+            assert_equal("37.0243902439024390", summary["average"])
+            assert(summary["max"] < 50)
+        }
+
+        count = 0
+        @query.summaries("name").each {|summary|
+            assert_equal(1, summary["count"])
+            count += 1
+        }
+        assert_equal(count, @query.count)
+
+    end
+
+    def testNumericSummary
+        summary = @query.summarise("age")
+        assert(summary["max"] < 50)
+        # Work around float comparison errors, grrr
+        assert(summary["average"] > 37.024)
+        assert(summary["average"] < 37.025)
+    end
+
+    def testNonNumericSummary
+        summary = @query.summarise("name")
+        assert_equal(1, summary["Tim Canterbury"])
+    end
+
+    def testTop
+        summary = @query.summaries("department.name")
+        top = summary.first
+        assert_equal("Warehouse", top["item"])
+        assert_equal(12, top["count"])
+    end
+
+    def testTemplateSummary
+        template = @service.template("CEO_Rivals")
+        template_params = {"A" => {"!=" => "Charles Miner"}}
+
+        summary = template.summarise("salary", template_params)
+        assert_equal(529119.4, summary["average"])
+
+        summary = template.summarise("company.name", template_params)
+        assert_equal(1, summary["Gogirep"])
+    end
+
+end

data/test/live_test.rb

@@ -6,7 +6,7 @@ require "intermine/service"
 class LiveDemoTest <  Test::Unit::TestCase
 
     def setup
-        @service = Service.new("localhost/intermine-test", "test-user-token")
+        @service = Service.new("http://localhost/intermine-test", "test-user-token")
         @temp_lists = []
     end
 
@@ -48,10 +48,10 @@ class LiveDemoTest <  Test::Unit::TestCase
     def testListEnumerability
         list = @service.list("My-Favourite-Employees")
         names = list.map {|emp| emp.name }
-        exp = ["David Brent", "Neil Godwin", "Bernd Stromberg", "Timo Becker"]
+        exp = [ "David Brent", "Neil Godwin", "Bernd Stromberg", "Timo Becker"]
         assert_equal(exp, names)
 
-        old = list.select {|emp| emp.age > 42}
+        old = list.select {|emp| emp.age > 43}
         assert_equal(1, old.size)
         assert_equal("Neil Godwin", old.first.name)
 
@@ -63,23 +63,23 @@ class LiveDemoTest <  Test::Unit::TestCase
         list = @service.list("My-Favourite-Employees")
 
         deps = list.map {|emp| emp.department.name }
-        exp = ["Sales", "Human Resources", 
-            "Schadensregulierung M-Z", "Schadensregulierung"]
+        exp = ["Sales", "Human Resources", "Schadensregulierung M-Z", "Schadensregulierung"]
         assert_equal(exp, deps)
 
         comps = list.map {|emp| emp.department.company.name }
-        exp = [ "Wernham-Hogg","Wernham-Hogg",
-              "Capitol Versicherung AG", "Capitol Versicherung AG"]
+        exp = ["Wernham-Hogg", "Wernham-Hogg", "Capitol Versicherung AG", "Capitol Versicherung AG"]
         assert_equal(exp, comps)
     end
 
     def testLazyCollectionFetching
         list = @service.list("My-Favourite-Employees")
         emps = list.map {|manager| manager.department.employees.map {|employee| employee.age} }
-        exp = [[41, 36, 55, 34, 61, 61],
-              [44, 49, 62],
-              [37, 45, 30, 64, 46, 58],
-              [37, 49, 39, 57, 36, 59]]
+        exp = [
+            [34, 36, 41, 55, 61, 61],
+            [44, 49, 62],
+            [30, 37, 45, 46, 58, 64],
+            [36, 37, 39, 49, 57, 59]
+        ]
         assert_equal(exp, emps)
 
         sum = list.reduce(0) {|m, manager| m + manager.department.employees.reduce(0) {|n, emp| n + emp.age}}
@@ -130,15 +130,10 @@ class LiveDemoTest <  Test::Unit::TestCase
         assert_equal(tags.sort, new_list.tags.sort)
     end
 
-    def testCoercingQueriesToLists
-        q1 = @service.query("Bank")
-        q2 = @service.query("Bank").where("corporateCustomers.id" => {'!=' => nil})
-
-        assert_equal(2, @service.query("Bank").where("Bank" => {:not_in => q2}).count)
-
-        l = @service.subtract([q1], [q2])
-        @temp_lists << l
-        assert_equal(2, l.size)
+    def testEnrichment
+        l = @service.list("My-Favourite-Employees")
+        contractors = l.calculate_enrichment :contractor_enrichment, :maxp => 1.0
+        assert_equal("Vikram", contractors.first[:identifier])
     end
 
 end

data/test/test_query.rb

@@ -640,6 +640,20 @@ class TestQuery < Test::Unit::TestCase
         assert_equal(conA.values, %w{Sales Marketing Janitorial})
     end
 
+    def test_range_constraints
+        query = InterMine::PathQuery::Query.new(@model, "Employee")
+        query.add_constraint({
+            :path => "age",
+            :op => "WITHIN",
+            :values => %w{1..10 30..35}
+        })
+
+        conA = query.constraints.first
+        assert_equal(conA.path.to_s, "Employee.age")
+        assert_equal(conA.op, "WITHIN")
+        assert_equal(conA.values, ["1..10", "30..35"])
+    end
+
     def test_bad_multi_constraint
         query = InterMine::PathQuery::Query.new(@model, "Employee")
         assert_raise ArgumentError do
@@ -848,12 +862,6 @@ class TestQuery < Test::Unit::TestCase
 
         assert_equal(query.sort_order.last.path, "Employee.name")
         assert_equal(query.sort_order.last.direction, "DESC")
-
-        query.add_sort_order("fullTime")
-
-        assert_equal(query.sort_order.last.path, "Employee.fullTime")
-        assert_equal(query.sort_order.last.direction, "ASC")
-
     end
 
     def test_subclassed_sort_order
@@ -981,6 +989,11 @@ class TestQuery < Test::Unit::TestCase
             :value => "zop",
             :extra_value => "zip"
         })
+        query.add_constraint({
+            :path => "age",
+            :op => "WITHIN",
+            :values => %w{1..10 30..35}
+        })
         query.add_constraint({
             :path => "Employee",
             :sub_class => "Manager"
@@ -998,6 +1011,9 @@ class TestQuery < Test::Unit::TestCase
         "<constraint loopPath='Employee.department.manager' op='=' code='E' path='Employee'/>" +
         "<constraint op='LOOKUP' code='F' value='quux' path='Employee'/>" + 
         "<constraint extraValue='zip' op='LOOKUP' code='G' value='zop' path='Employee'/>" + 
+        "<constraint op='WITHIN' code='H' path='Employee.age'>" +
+           "<value>1..10</value><value>30..35</value>" +
+        "</constraint>" +
         "</query>"
 
         compare_xml(expected, query.to_xml.to_s)

data/test/test_result_row.rb

@@ -12,14 +12,9 @@ class TestResults < Test::Unit::TestCase
         super
         file = File.new(
             File.dirname(__FILE__) + "/data/resultrow.json", "r")
-        file2 = File.new(
-            File.dirname(__FILE__) + "/data/resultrow_new.json", "r")
         @data = file.read
-        @data2 = file2.read
         @json = JSON.parse(@data)
-        @json2 = JSON.parse(@data2)
         @view = ["Company.departments.name","Company.departments.manager.name", "Company.departments.manager.age"]
-        @view2 = ["Company.departments.name","Company.departments.manager.name", "Company.departments.manager.age", "Company.address.address"]
         @bad_view = ["Company.departments.name","Company.departments.manager.name"]
     end
 
@@ -47,31 +42,6 @@ class TestResults < Test::Unit::TestCase
         end
     end
 
-    def test_array_access2
-
-        rr = NewResultRow.new(@data2, @view2)
-
-        assert_equal(rr[0], "DepartmentA1")
-        assert_equal(rr[1], "EmployeeA1")
-
-        rr = NewResultRow.new(@json2, @view2)
-
-        assert_equal(rr[0], "DepartmentA1")
-        assert_equal(rr[1], "EmployeeA1")
-
-        assert_equal(rr[1..2], ["EmployeeA1", 33])
-        assert_equal(rr[0, 2], ["DepartmentA1", "EmployeeA1"])
-
-        assert_equal(rr.first, "DepartmentA1")
-        assert_equal(rr[3], nil)
-        assert_equal(rr.last, nil)
-
-        assert_raise IndexError do
-            rr[4]
-        end
-
-    end
-
     def test_array_access
 
         rr = ResultsRow.new(@data, @view)

data/test/test_sugar.rb

@@ -32,13 +32,14 @@ class TestQuerySugar < Test::Unit::TestCase
 
     def test_view_expansion
         q = @model.table("Employee").select("*", "department.*")
-        expected = ["Employee.name",
+        expected = [
+         "Employee.age",
          "Employee.end",
-         "Employee.id",
          "Employee.fullTime",
-         "Employee.age",
-         "Employee.department.name",
-         "Employee.department.id"]
+         "Employee.id",
+         "Employee.name",
+         "Employee.department.id",
+         "Employee.department.name"]
 
         assert_equal(expected, q.views.map {|x| x.to_s})
     end
@@ -50,7 +51,7 @@ class TestQuerySugar < Test::Unit::TestCase
                    where(:name => {"=" => nil}).
                    where(:fullTime => {"!=" => nil})
 
-        expected = "<query model='testmodel' sortOrder='Employee.name ASC' view='Employee.name Employee.end Employee.id Employee.fullTime Employee.age'>" +
+        expected = "<query model='testmodel' sortOrder='Employee.age ASC' view='Employee.age Employee.end Employee.fullTime Employee.id Employee.name'>" +
                         "<constraint op='IS NULL' code='A' path='Employee.age'/>" +
                         "<constraint op='IS NULL' code='B' path='Employee.name'/>" +
                         "<constraint op='IS NOT NULL' code='C' path='Employee.fullTime'/>" + 
@@ -68,7 +69,7 @@ class TestQuerySugar < Test::Unit::TestCase
                    where("department.name" => {:contains => "foo"}).
                    where(:name => {"!=" => "bar"})
 
-        expected = "<query model='testmodel' sortOrder='Employee.name ASC' view='Employee.name Employee.end Employee.id Employee.fullTime Employee.age'>" +
+        expected = "<query model='testmodel' sortOrder='Employee.age ASC' view='Employee.age Employee.end Employee.fullTime Employee.id Employee.name'>" +
                         "<constraint op='=' code='A' value='foo' path='Employee.name'/>" + 
                         "<constraint op='=' code='B' value='10' path='Employee.age'/>" + 
                         "<constraint op='&lt;' code='C' value='200' path='Employee.end'/>" +
@@ -90,7 +91,7 @@ class TestQuerySugar < Test::Unit::TestCase
                    where(:name => {:ne => "bar"}).
                    where(:name => {:== => "zop"})
 
-        expected = "<query model='testmodel' sortOrder='Employee.name ASC' view='Employee.name Employee.end Employee.id Employee.fullTime Employee.age'>" +
+        expected = "<query model='testmodel' sortOrder='Employee.age ASC' view='Employee.age Employee.end Employee.fullTime Employee.id Employee.name'>" +
                         "<constraint op='&lt;' code='A' value='100' path='Employee.age'/>" + 
                         "<constraint op='&gt;' code='B' value='200' path='Employee.age'/>" + 
                         "<constraint op='&lt;=' code='C' value='300' path='Employee.age'/>" + 
@@ -110,7 +111,7 @@ class TestQuerySugar < Test::Unit::TestCase
                    where(:department => {:lookup => "foo"}).
                    where("department.company" => {:lookup => "foo", :with => "extra"})
 
-        expected = "<query model='testmodel' sortOrder='Employee.name ASC' view='Employee.name Employee.end Employee.id Employee.fullTime Employee.age'>" +
+        expected = "<query model='testmodel' sortOrder='Employee.age ASC' view='Employee.age Employee.end Employee.fullTime Employee.id Employee.name'>" +
                         "<constraint op='LOOKUP' code='A' value='foo' path='Employee.department'/>" + 
                         "<constraint extraValue='extra' op='LOOKUP' code='B' value='foo' path='Employee.department.company'/>" + 
                 "</query>"
@@ -127,7 +128,7 @@ class TestQuerySugar < Test::Unit::TestCase
                    where("Employee.department" => {:in => "a list"}).
                    where("Employee.department.company" => {:not_in => "a list"})
 
-        expected = "<query model='testmodel' sortOrder='Employee.name ASC' view='Employee.name Employee.end Employee.id Employee.fullTime Employee.age'>" +
+        expected = "<query model='testmodel' sortOrder='Employee.age ASC' view='Employee.age Employee.end Employee.fullTime Employee.id Employee.name'>" +
                         "<constraint op='IN' code='A' value='test-list' path='Employee'/>" +
                         "<constraint op='IN' code='B' value='test-list' path='Employee.department.manager'/>" +
                         "<constraint op='NOT IN' code='C' value='test-list' path='Employee.department.manager'/>" +
@@ -152,7 +153,7 @@ class TestQuerySugar < Test::Unit::TestCase
                    where("department.manager.age" => {:none_of => [46, 47]}).
                    where("department.manager.end" => {:one_of => [56, 57]})
 
-        expected = "<query model='testmodel' sortOrder='Employee.name ASC' view='Employee.name Employee.end Employee.id Employee.fullTime Employee.age'>" +
+        expected = "<query model='testmodel' sortOrder='Employee.age ASC' view='Employee.age Employee.end Employee.fullTime Employee.id Employee.name'>" +
                        "<constraint op='ONE OF' code='A' path='Employee.age'>" + 
                             "<value>30</value><value>31</value><value>32</value><value>33</value><value>34</value><value>35</value>" +
                        "</constraint>" + 
@@ -194,7 +195,7 @@ class TestQuerySugar < Test::Unit::TestCase
                    where("department.company.CEO" => {:is => "department.manager"}).
                    where("department.company.CEO" => {:is_not => "department.employees"})
 
-        expected = "<query model='testmodel' sortOrder='Employee.name ASC' view='Employee.name Employee.end Employee.id Employee.fullTime Employee.age'>" +
+        expected = "<query model='testmodel' sortOrder='Employee.age ASC' view='Employee.age Employee.end Employee.fullTime Employee.id Employee.name'>" +
                         "<constraint op='=' loopPath='Employee.department.manager' code='A' path='Employee.department.company.CEO'/>" + 
                         "<constraint op='!=' loopPath='Employee.department.employees' code='B' path='Employee.department.company.CEO'/>" + 
                 "</query>"
@@ -209,7 +210,7 @@ class TestQuerySugar < Test::Unit::TestCase
                    where("department.employees" => manager).
                    where("department.employees" => {:sub_class => "CEO"})
 
-        expected = "<query model='testmodel' sortOrder='Employee.name ASC' view='Employee.name Employee.end Employee.id Employee.fullTime Employee.age'>" +
+        expected = "<query model='testmodel' sortOrder='Employee.age ASC' view='Employee.age Employee.end Employee.fullTime Employee.id Employee.name'>" +
                         "<constraint type='Manager' path='Employee.department.employees'/>" +
                         "<constraint type='CEO' path='Employee.department.employees'/>" +
                 "</query>"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: intermine
 version: !ruby/object:Gem::Version 
-  hash: 405
+  hash: 23
   prerelease: 
   segments: 
+  - 1
   - 0
-  - 99
-  - 3
-  version: 0.99.03
+  - 0
+  version: 1.00.00
 platform: ruby
 authors: 
 - Alex Kalderimis
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-18 00:00:00 Z
+date: 2012-10-08 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json
@@ -133,6 +133,8 @@ files:
 - test/data/resultrow.json
 - test/data/resultset.json
 - test/data/testmodel_model.xml
+- test/live_results.rb
+- test/live_summary_test.rb
 - test/live_test.rb
 - test/test.rb
 - test/test_helper.rb
@@ -148,7 +150,6 @@ files:
 - LICENCE
 - Rakefile
 - README.rdoc
-- TODO
 - Gemfile
 - contact_header.rdoc
 homepage: http://www.intermine.org
@@ -184,7 +185,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: intermine
-rubygems_version: 1.7.2
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Webservice Client Library for InterMine Data-Warehouses

data/TODO

@@ -1,3 +0,0 @@
-json formats (and benchmarks)
-test for CD.find
-