rally_rest_api 0.5.9 → 0.6.0

data/Rakefile

@@ -39,7 +39,7 @@ hoe = Hoe.new(GEM_NAME, VERS) do |p|
   p.summary = DESCRIPTION
   p.url = HOMEPATH
   p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
-  p.test_globs = ["test/**/tc_*.rb"]
+  p.test_globs = ["test/*.rb"]
   p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
   p.extra_deps = ["builder"]
 

data/lib/rally_rest_api/query.rb

@@ -18,6 +18,12 @@ class Symbol # :nodoc: all
     end
 end
 
+class NilClass
+  def to_q
+    "null"
+  end
+end
+
 # == Generate a query string for Rally's webservice query interface.
 # Arguments are:
 #  type - the type to query for
@@ -73,6 +79,8 @@ class RestQuery
   def initialize(type, args = {}, &block)
     @type = type
     @query_string = "query=" << URI.escape(QueryBuilder.new("and", &block).to_q) if block_given?
+    @args_for_paging = {}
+    [:workspace, :project, :project_scope_down, :project_scope_up].each { |k| @args_for_paging[k] = args[k] if args.key?(k) }
     @query_params = process_args(args)
   end
 
@@ -91,7 +99,7 @@ class RestQuery
   end
 
   def next_page(args)
-    @query_params = process_args(args)
+    @query_params = process_args(args.merge(@args_for_paging))
     self
   end
 

data/lib/rally_rest_api/query_result.rb

@@ -1,4 +1,4 @@
-require 'rally_rest_api/rest_object'
+require File.dirname(__FILE__) + '/rest_object'
 
 # == An interface to the paged query result 
 #
@@ -36,7 +36,6 @@ class QueryResult < RestObject
     @start_index = elements[:start_index].to_i
   end
 
-require 'active_support/breakpoint'
   # fetch the next page of results. Uses the original query to generate the query string.
   def next_page
     @rally_rest.query(@query.next_page(:start => self.start_index + self.page_size,
@@ -54,7 +53,7 @@ require 'active_support/breakpoint'
 	yield result.dup
       end
       current_result = current_result.next_page if current_result.more_pages?
-    end while last_result != current_result
+    end while !last_result.equal? current_result
   end
 
   # return the first element. Useful for queries that return only one result

data/lib/rally_rest_api/rally_rest.rb

@@ -3,10 +3,6 @@ require 'uri'
 require 'rexml/document'
 require 'ostruct'
 
-require 'rally_rest_api/rest_builder'
-require 'rally_rest_api/query'
-require 'rally_rest_api/rest_object'
-require 'rally_rest_api/query_result'
 
 #
 # RallyRestAPI - A Ruby-ized interface to Rally's REST webservice API
@@ -79,7 +75,7 @@ class RallyRestAPI
   end
 
   # find all object of a given type. Base types work also (.e.g :artifact)
-  def find_all(type, *args)
+  def find_all(type, args = {})
     find(type, args) { gt :object_i_d, "0" }
   end
 

data/lib/rally_rest_api/rest_builder.rb

@@ -170,7 +170,7 @@ module RestBuilder # :nodoc:
   end
 
 
-  COLLECTION_TYPES = [:dependents, :dependencies, :defects]
+  COLLECTION_TYPES = [:dependents, :dependencies, :defects, :duplicates]
   def collection_type?(type)
     COLLECTION_TYPES.include?(type)
   end

data/lib/rally_rest_api/rest_object.rb

@@ -1,4 +1,4 @@
-require 'rally_rest_api/rest_builder'
+require File.dirname(__FILE__) + '/rest_builder'
 
 # == An interface to a Rally resource
 # RestObject is an adapter that is initialized with a resource ref (URL) that represents a Rally object. The adapter
@@ -145,6 +145,11 @@ class RestObject
     @document.root.attributes["type"] || @document.root.name
   end
 
+  # the type as symbol
+  def type_as_symbol
+    underscore(self.type).intern
+  end
+
   # The oid of the underlying resource
   def oid
     self.elements[:object_id]
@@ -173,6 +178,10 @@ class RestObject
     @elements
   end
 
+   def ==(other)
+     other.ref == self.ref
+   end
+
   public 
   
   # update the resource. This will re-read the resource after the update

data/lib/rally_rest_api/typedef.rb

@@ -1,49 +1,86 @@
+require 'pp'
+class TypeDefinition < RestObject # :nodoc:
 
-require 'rally_rest_api/rest_object'
+  def self.cached_type_definitions
+    @@cached_type_definitions ||= {}
+  end
 
-class TypeDefinition < RestObject # :nodoc:
+  def self.cached_type_definition(workspace_domain_object, type = workspace_domain_object.type)
+    key = make_key(workspace_domain_object.workspace, type)
 
-  def self.cached_type_definition(workspace_domain_object)
-    # todo, actually cache the value
-    typedef = workspace_domain_object.workspace.type_definitions.values.find do |typedef|
-      puts "#{workspace_domain_object.type} == #{typedef.element_name}"
-      workspace_domain_object.type == typedef.element_name
+    unless cached_type_definitions.key? key
+      cached_type_definitions[key] = get_type_definition(workspace_domain_object.workspace, type)
     end
+    cached_type_definitions[key]
+  end
+
+  def self.get_type_definition(workspace, type)
+    mangle_type_definitions(workspace.type_definitions)
+    typedef = workspace.type_definitions[type]
     TypeDefinition.new(typedef.rally_rest, typedef.body)
   end
 
+  # This is a hack
+  # Strip spaces from the name, and put the values back in to the hash
+  def self.mangle_type_definitions(type_definitions)
+    type_definitions.each do |key, value|
+      type_definitions[key.gsub(" ", "")] = value if key.include? " "
+    end
+  end
+
+  def self.make_key(workspace, type)
+    # Parent typedefs don't have a workspace, so key them appropriately
+    ref = workspace.ref rescue ""
+    type + ref
+  end
+
+  def custom_attributes
+    collect_attributes { |element_name, attrdef| attrdef.custom == "true" }
+  end
+
+  # custom and constrained, i.e. a custom dropdown
+  def custom_constrained_attributes
+    collect_attributes { |element_name, attrdef| attrdef.custom == "true" && attrdef.constrained == "true" }
+  end
+  alias custom_dropdown_attributes custom_constrained_attributes 
+
+  def constrained_attributes
+    collect_attributes { |element_name, attrdef| attrdef.constrained == "true" }
+  end
+
   def collection_attributes(include_parent = false)
-    collect_attributes_of_type("COLLECTION", include_parent)
+    collect_attributes(include_parent) { |element_name, attrdef| attrdef.attribute_type == "COLLECTION" }
   end
 
   def object_attributes(include_parent = false)
-    collect_attributes_of_type("OBJECT", include_parent)
+    collect_attributes(include_parent) do |element_name, attrdef| 
+      attrdef.attribute_type == "OBJECT" 
+    end
   end
 
   def reference_attributes(include_parent = false)
     collection_attributes(include_parent).merge object_attributes(include_parent)
   end
 
-  def collect_attributes_of_type(type, include_parent)
-    self.attributes(include_parent).inject({}) do |h, (element_name, attrdef)|
-      h[element_name] = attrdef if attrdef.attribute_type == type
-      h
-    end
+  def collect_attributes(include_parent = false)
+    values = self.attributes(include_parent).find_all { |element_name, attrdef| yield element_name, attrdef }
+    Hash[*values.flatten]
   end
 
-  def symbol_keyed_attributes(attribute_array)
-    attribute_array.inject({}) do |hash, attrdef|
-      hash[underscore(attrdef.element_name).intern] = attrdef
+  def symbol_keyed_attributes(attribute_hash)
+    return {} unless attribute_hash  # some typedefs will have no attributes
+    attribute_hash.values.inject({}) do |hash, attrdef|
+      hash[underscore(attrdef.element_name).intern] = AttributeDefinition.new(self.rally_rest, attrdef)
       hash
     end
   end
 
   def attributes(include_parent = false)
-    return symbol_keyed_attributes(self.elements[:attributes].values) unless include_parent
+    return symbol_keyed_attributes(self.elements[:attributes]) unless include_parent
 
     typedef = self
     all_attributes = {}
-    until typedef.parent.nil?
+    until typedef.nil?
       all_attributes.merge! typedef.attributes(false)
       typedef = typedef.parent
     end
@@ -52,7 +89,17 @@ class TypeDefinition < RestObject # :nodoc:
 
   def parent
     return nil if self.elements[:parent].nil?
-    TypeDefinition.new(self.rally_rest, self.elements[:parent].body)
+    cached_parent
+  end
+
+  def cached_parent
+    type_no_spaces = self.elements[:parent].name.gsub(" ", "")
+    key = TypeDefinition.make_key(self.workspace, type_no_spaces)
+    typedef = TypeDefinition.cached_type_definitions[key]
+    if typedef.nil?
+      typedef = TypeDefinition.cached_type_definitions[key] = TypeDefinition.new(self.rally_rest, self.elements[:parent].body)
+    end
+    typedef
   end
   
 end

data/lib/rally_rest_api/version.rb

@@ -1,8 +1,8 @@
 module RallyRestVersion #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 5
-    TINY  = 9
+    MINOR = 6
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/attribute_definition_spec.rb

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'spec'
+require 'builder'
+require 'ostruct'
+require 'rally_rest_api'
+
+
+context "An attribute definition for a custom dropdown" do
+
+  setup do
+    @b = Builder::XmlMarkup.new(:indent => 2)
+    @b.instruct!
+    
+    xml = @b.AttributeDefinition(:ref => "http://bla/bla/bla", 
+				 :refObjectName => "Custom Dropdown") {
+      @b.Name("Custom Dropdown")
+      @b.AttributeType("STRING")
+      @b.ElementName("CustomDropdown")
+      @b.Constrained("true")
+      @b.Custom("true")
+
+      @b.AllowedValues {
+	@b.AllowedAttributeValue(:ref => "null") {
+	  @b.StringValue
+	}
+	@b.AllowedAttributeValue(:ref => "null") {
+	  @b.StringValue("Actor")
+	}
+      }
+    }
+    fake_rally_rest = OpenStruct.new(:username => "", :password => "")
+    @attrdef = AttributeDefinition.new(fake_rally_rest, RestObject.new(fake_rally_rest, xml).elements)    
+  end
+
+  specify "should have 'Custom Dropdown' as the name" do
+    @attrdef.name.should == "Custom Dropdown"
+  end
+
+  specify "should return an arry of allowed values" do
+    @attrdef.allowed_values.should_be_instance_of Array
+  end
+
+  specify "should have 2 allowd values" do
+    @attrdef.allowed_values.length.should == 2
+  end
+
+  specify "should not return an array of hashes" do
+    @attrdef.allowed_values.each { |value| value.should_not_be_instance_of Hash }
+  end
+  
+  specify "allowed_values should match" do
+    @attrdef.allowed_values.should == [nil, "Actor"]
+  end
+end

data/test/spec_typedef.rb

@@ -0,0 +1,83 @@
+require 'rubygems'
+require 'spec'
+require 'ostruct'
+require 'rally_rest_api'
+
+
+context "A Test Case type definition with 2 collection attribues, 1 object attributes, and 1 string attribute" do
+  
+  setup do
+    @b = Builder::XmlMarkup.new(:indent => 2)
+    @b.instruct!
+    
+    xml = @b.TypeDefinition(:ref => "https://rally1.rallydev.com:443/slm/webservice/1.0/typedefinition/31552422",
+		      :refObjectName => "Test Case",
+		      :type => "TypeDefinition") {
+      @b.ElementName("TestCase")
+      @b.Attributes {
+	{"Notes"             => {:type => "TEXT", :element_name => "Notes", :constrained => "false", :custom => "false"},
+	  "Test Case Result" => {:type => "COLLECTION", :element_name => "TestCaseResult", :constrained => "false", :custom => "false"},
+	  "Foo Bar"          => {:type => "COLLECTION", :element_name => "FooBar", :constrained => "false", :custom => "false"},
+	  "Requirement"      => {:type => "OBJECT", :element_name => "Requirement", :constrained => "false", :custom => "false"},
+          "Constrained"      => {:type => "STRING", :element_name => "Constrained", :constrained => "true", :custom => "false"},
+	  "Custom"           => {:type => "STRING", :element_name => "Custom", :constrained => "false", :custom => "true"},
+	  "ConstainedCustom" => {:type => "STRING", :element_name => "ConstrainedCustom", :constrained => "true", :custom => "true"}
+	}.each do |name, type|
+	  @b.AttributeDefinition(:ref => "http://bla/bla/bla", 
+				 :refObjectName => name) {
+	      @b.AttributeType(type[:type])
+	      @b.ElementName(type[:element_name])
+	      @b.Constrained(type[:constrained])
+	      @b.Custom(type[:custom])
+	  }
+	end
+      }
+    }
+    @typedef = TypeDefinition.new(OpenStruct.new(:username => "", :password => ""), xml)
+  end
+
+  specify "all attribute keys are symbols" do
+    @typedef.attributes.keys.each { |a| a.should_be_instance_of Symbol }
+  end
+
+  specify "there should be 2 collection attributes" do
+    @typedef.collection_attributes.size.should == 2
+  end
+  
+  specify "the :test_case_result attribute should exist" do
+    @typedef.collection_attributes[:test_case_result].should_not_be_nil
+  end
+
+  specify "All the collection attributes keys should be symbols" do
+    @typedef.collection_attributes.keys.each { |a| a.should_be_instance_of Symbol }
+  end
+  
+  specify "there should be 1 object attribute" do
+    @typedef.object_attributes.size.should == 1
+  end
+
+  specify "the :requirement attribute should exist" do
+    @typedef.object_attributes[:requirement].should_not_be_nil
+  end
+
+  specify "should have 2 constrained attributes" do
+    @typedef.constrained_attributes.size.should == 2
+  end
+
+  specify "should have 2 cusom attributes" do
+    @typedef.custom_attributes.size.should == 2
+  end
+
+  specify "should have 1 custom_constrained_attributes" do
+    @typedef.custom_constrained_attributes.size.should == 1
+    @typedef.custom_dropdown_attributes.size.should == 1
+  end
+
+  specify "#attributes should return instances of AttributeDefinitions" do
+    @typedef.attributes.values.each { |attrdef| attrdef.should_be_instance_of AttributeDefinition }
+  end
+
+  specify  "parent should be nil" do
+    @typedef.parent.should_be_nil
+  end
+end

data/test/tc_query_result.rb

@@ -1,7 +1,8 @@
 require 'test/unit'
 require 'test/unit/testcase'
 
-require 'rally_rest_api/rally_rest'
+require 'rubygems'
+require 'rally_rest_api'
 
 class QueryResultTestCase < Test::Unit::TestCase
   

data/test/tc_rest_api.rb

@@ -1,7 +1,8 @@
 require 'test/unit'
 require 'test/unit/testcase'
 
-require 'rally_rest_api/rally_rest'
+require 'rubygems'
+require 'rally_rest_api'
 
 class RestApiTestCase < Test::Unit::TestCase
 

data/test/tc_rest_object.rb

@@ -2,7 +2,9 @@
 require 'test/unit'
 require 'test/unit/testcase'
 
-require 'rally_rest_api/rally_rest'
+require 'rubygems'
+require 'rally_rest_api'
+
 
 # We need to override read_rest from RestBuilder, So redefine it here
 # We need a way to inject the xml that will be read by a RestObject when 

data/test/tc_rest_query.rb

@@ -1,6 +1,8 @@
 
 require "test/unit"
-require 'rally_rest_api/query'
+
+require 'rubygems'
+require 'rally_rest_api'
 
 class TestRestQuery < Test::Unit::TestCase
   # RestQuery.find(:feature).where {  # default is and

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: rally_rest_api
 version: !ruby/object:Gem::Version 
-  version: 0.5.9
-date: 2006-11-30 00:00:00 -07:00
+  version: 0.6.0
+date: 2006-12-13 00:00:00 -07:00
 summary: A ruby-ized interface to Rally's REST webservices API
 require_paths: 
 - lib
@@ -52,7 +52,10 @@ test_files:
 - test/tc_rest_api.rb
 - test/tc_rest_object.rb
 - test/tc_rest_query.rb
+- test/test_helper.rb
 - test/tc_query_result.rb
+- test/spec_typedef.rb
+- test/attribute_definition_spec.rb
 rdoc_options: []
 
 extra_rdoc_files: []