intermine 0.98.11 → 0.99.00

data/TODO

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

data/lib/intermine/lists.rb

@@ -675,13 +675,10 @@ module InterMine::Lists
         def make_list_names(objs)
             current_names = list_names
             return objs.map do |x|
-                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
+                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
                 else
                     raise ArgumentError, "#{x} is not a list you can access"
                 end
@@ -711,15 +708,17 @@ module InterMine::Lists
             else
                 begin
                     container = JSON.parse(response.body)
-                    raise ServiceError, container["error"]
+                    err = 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,
@@ -731,6 +730,19 @@ 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,6 +402,46 @@ 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
         #
@@ -749,11 +789,55 @@ 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
@@ -880,6 +964,9 @@ module Metadata
             end
         end
     end
+
+    class ItemNotFoundError < RuntimeError
+    end
 end
 end
 

data/lib/intermine/query.rb

@@ -762,6 +762,32 @@ 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 
@@ -826,7 +852,7 @@ module InterMine::PathQuery
                                 end
                                 parameters[:values] = subv.to_a
                             elsif subv.is_a?(Lists::List)
-                                if subk == "="
+                                if subk == "=" or subk == "<" or subk == "<="
                                     parameters[:op] = "IN"
                                 elsif subk == "!="
                                     parameters[:op] = "NOT IN"
@@ -834,6 +860,19 @@ 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

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| x["value"]}
+                return @results[arg, length].map {|x| value_of(x)}
             end
 
             case arg
             when Range
-                return @results[arg].map {|x| x["value"]}
+                return @results[arg].map {|x| value_of(x)}
             when Integer
                 idx = arg
             else
@@ -103,17 +103,17 @@ module InterMine::Results
 
             raise IndexError, "Argument out of range" if cell.nil?
 
-            return cell["value"]
+            return value_of(cell)
         end
 
         # Returns the first value in this row
         def first
-            return @results[0]["value"]
+            return value_of(@results[0])
         end
 
         # Returns the last value in this row
         def last
-            return @results.last["value"]
+            return value_of(@results.last)
         end
 
         # Iterate over the values in this row in the
@@ -134,9 +134,11 @@ module InterMine::Results
         def each(&block) 
             if block
                 if block.arity == 1
-                    @results.each {|x| block.call(x["value"])}
+                    @results.each {|x| block.call(value_of(x))}
                 else block.arity == 2
-                    (0 ... @results.size).to_a.each {|i| block.call(@columns[i], @results[i]["value"])}
+                    (0 ... @results.size).to_a.each {|i| 
+                        block.call(@columns[i], value_of(@results[i]))
+                    }
                 end
             end
             return self
@@ -154,7 +156,7 @@ module InterMine::Results
 
         # Return an Array version of the row.
         def to_a
-            return @results.map {|x| x["value"]}
+            return @results.map {|x| value_of(x)}
         end
 
         # Return a Hash version of the row. All keys in this
@@ -185,11 +187,15 @@ 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| x["value"].inspect}.join(sep)
+            return @results.map {|x| value_of(x).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?
@@ -209,6 +215,13 @@ 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|
@@ -250,11 +263,13 @@ 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 : ResultsRow.new(x, @query.views)
+                x.empty? ? nil : cls.new(x, @query.views)
             }
-            read_result_set(params("jsonrows"), processor) {|x|
+            read_result_set(params(format), processor) {|x|
                 yield x
             }
         end

data/lib/intermine/version.rb

@@ -12,5 +12,7 @@ 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
-    VERSION = "0.98.11"
+    #   0.99.00 - Added coercion from query to lists in "IN/NOT IN" constraints
+    #           - Added support for "json" format (performance) improvement
+    VERSION = "0.99.00"
 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/intermine-test", "Z1a3D3U16cicCdS0T6y4bdN1SQh")
+        @service = Service.new("localhost/intermine-test", "test-user-token")
         @temp_lists = []
     end
 
@@ -48,42 +48,42 @@ class LiveDemoTest <  Test::Unit::TestCase
     def testListEnumerability
         list = @service.list("My-Favourite-Employees")
         names = list.map {|emp| emp.name }
-        exp = ["Bernd Stromberg", "David Brent", "Neil Godwin", "Timo Becker"]
+        exp = ["David Brent", "Neil Godwin", "Bernd Stromberg", "Timo Becker"]
         assert_equal(exp, names)
 
-        old = list.select {|emp| emp.age > 55}
+        old = list.select {|emp| emp.age > 42}
         assert_equal(1, old.size)
-        assert_equal("David Brent", old.first.name)
+        assert_equal("Neil Godwin", old.first.name)
 
         sum = list.reduce(0) {|m, i| m + i.age}
-        assert_equal(185, sum)
+        assert_equal(159, sum)
     end
 
     def testLazyReferenceFetching
         list = @service.list("My-Favourite-Employees")
 
         deps = list.map {|emp| emp.department.name }
-        exp = ["Schadensregulierung M-Z", "Sales", 
-            "Human Resources", "Schadensregulierung"]
+        exp = ["Sales", "Human Resources", 
+            "Schadensregulierung M-Z", "Schadensregulierung"]
         assert_equal(exp, deps)
 
         comps = list.map {|emp| emp.department.company.name }
-        exp = ["Capitol Versicherung AG", "Wernham-Hogg",
-              "Wernham-Hogg", "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 = [[42, 28, 29, 46, 28, 48],
-            [62, 64, 58, 35, 36, 46],
-            [41, 57, 36],
-            [63, 37, 61, 55, 58, 45]]
+        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}}
-        assert_equal(975, sum)
+        assert_equal(1000, sum)
     end
 
     def testListCreation
@@ -130,4 +130,15 @@ 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)
+    end
+
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: intermine
 version: !ruby/object:Gem::Version 
-  hash: 385
-  prerelease: false
+  hash: 403
+  prerelease: 
   segments: 
   - 0
-  - 98
-  - 11
-  version: 0.98.11
+  - 99
+  - 0
+  version: 0.99.00
 platform: ruby
 authors: 
 - Alex Kalderimis
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-01 00:00:00 +00:00
-default_executable: 
+date: 2011-12-12 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json
@@ -149,9 +148,9 @@ files:
 - LICENCE
 - Rakefile
 - README.rdoc
+- TODO
 - Gemfile
 - contact_header.rdoc
-has_rdoc: true
 homepage: http://www.intermine.org
 licenses: 
 - LGPL
@@ -185,7 +184,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: intermine
-rubygems_version: 1.3.7
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: Webservice Client Library for InterMine Data-Warehouses