rally_workspace_utils 0.0.4 → 0.0.6

data/Manifest.txt

@@ -12,7 +12,12 @@ lib/translate/copy/rest_object.rb
 lib/translate/copy/story_copy.rb
 lib/translate/copy/test_case_result_copy.rb
 lib/translate/copy/defect_copy.rb
+lib/translate/copy/feature_copy.rb
+lib/translate/copy/use_case_copy.rb
+lib/translate/copy/supplemental_requirement_copy.rb
+lib/translate/copy/card_copy.rb
 lib/translate/copy/object_copy.rb
+lib/translate/copy/requirement_copy.rb
 lib/translate/copy/test_case_copy.rb
 lib/translate/translation_store.rb
 test/translation_store_spec.rb

data/Rakefile

@@ -43,7 +43,7 @@ hoe = Hoe.new(GEM_NAME, VERS) do |p|
   p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
 
   p.extra_deps = []
-  p.extra_deps << ["rally_rest_api", ">= 0.6.3"]
+  p.extra_deps << ["rally_rest_api", ">= 0.6.4"]
   p.extra_deps << ["activesupport"]
 
   

data/bin/translate_workspace

@@ -6,8 +6,17 @@ require 'getoptlong'
 require 'logger'
 require 'rubygems'
 require 'rally_rest_api'
-
 require 'rally_workspace_utils'
+require 'active_support'
+
+# Undo the logger stuff thatr active_support puts in.
+class Logger
+  private
+  def format_message(severity, datetime, progname, msg)
+    (@formatter || @default_formatter).call(severity, datetime, progname, msg)
+  end
+end
+
 
 opts = GetoptLong.new(
                       ["--base_url", "-b", GetoptLong::REQUIRED_ARGUMENT],

data/lib/translate/copy.rb

@@ -3,7 +3,13 @@ require 'rally_rest_api'
 
 require 'translate/copy/rest_object'
 require 'translate/copy/object_copy'
+require 'translate/copy/scheduled_story_as_work_product'
 require 'translate/copy/defect_copy'
+require 'translate/copy/card_copy'
+require 'translate/copy/requirement_copy'
+require 'translate/copy/feature_copy'
+require 'translate/copy/use_case_copy'
+require 'translate/copy/supplemental_requirement_copy'
 require 'translate/copy/story_copy'
 require 'translate/copy/test_case_copy'
 require 'translate/copy/test_case_result_copy'

data/lib/translate/copy/card_copy.rb

@@ -0,0 +1,36 @@
+class CardCopy < ObjectCopy
+  def shallow_copy(object)
+    # We are here because we have an artifact with multiple cards. We need to create
+    # a user story for each artifact:card pair, and we are going to do it from the perspective 
+    # of the card. The "parent" card has already been created
+    # 
+    # so, let's shallow copy the workproduct values first
+    values = super(@object.work_product)
+    
+    # then get the interesting card attrributes
+    values.merge! card_values(@object)
+
+    # append to the name attribute
+    values[:name] = "Scheduled child of #{values[:name]}"
+
+    # Capture the schedule note
+    values[:notes] = "#{values[:notes]} <br> Scheduled Note: #{@object.schedule_note}"
+
+    values
+  end
+
+  def create_object(values)
+    rally_rest.create(:hierarchical_requirement, values)
+  end
+
+  def copy_children
+    @object.tasks.each do |task|
+      task.copy(new_workspace, :work_product => @new_object)
+    end if @object.tasks
+  end
+
+  def type_as_symbol
+    :hierarchical_requirement
+  end
+
+end

data/lib/translate/copy/defect_copy.rb

@@ -1,75 +1,57 @@
 class DefectCopy < ObjectCopy
-
-  def shallow_copy(object, new_workspace)
+  def shallow_copy(object)
     values = super
-    values.delete(:submitted_by) unless user_exists? @object.submitted_by
+    values.delete(:submitted_by) unless user_exists? object.submitted_by
     values
   end
   
-  def tangle(new_workspace)
-    values = {}
-    new_defect = fetch_object(:defect, @object.oid, new_workspace)
-
-    # If the original defect is in a different project from the stories' card,
-    # then create a new user story, as the parent of this new user story, and make
-    # the requirement on the defect this new story
-    if @object.requirement != nil && @object.requirement.cards != nil && # The defect has a requirement, that is scheduled
-	@object.project != nil &&                                           # The defect in not in the parent project
-	@object.requirement.cards.first.project != @object.project         # The card in in a different project from the defect
+  def tangle
+    super
 
-      story_name = @object.requirement.name
-      new_requirement = fetch_object(:artifact, @object.requirement.oid, new_workspace)
-      if new_requirement.parent && new_requirement.parent.project.nil?
-	parent_story = new_requirement.parent
-      else
-	parent_story = new_workspace.rally_rest.create(:hierarchical_requirement, 
-						       :workspace => new_workspace,
-						       :name => "Parent story for UserStory '#{story_name}' to hold defects in project #{@object.project.name}")
-	@object.rally_rest.logger.info "During the tangle of defect '#{@object.name}' we needed to create a new UserStory and make it the parent of this defect's requirement. This is because the original Story was scheduled into a project that was diffetent than the project this defect is in."
-      end
-      new_requirement.update(:parent => parent_story)
-      values[:requirement] = parent_story
-    else
-      
-      # if the old defect has a test case
-      unless @object.test_case.nil?
-	# get the new test_case
-	new_test_case = fetch_object(:test_case, @object.test_case.oid, new_workspace)
-	# update
-	values[:test_case] = new_test_case
+    if @new_object.nil?
+      logger.debug "Could not find new object for object #{@object.oid} -- #{@object.name}"
+      return
+    end
 
-	# if the new defect is in the Parent Project and 
-	# the its related test_case is not in the same project as the defect,
-	# then put the defect in the same project as the test_case
-	if new_defect.project.nil? && new_defect.project != new_test_case.project
-	  values[:project] = new_test_case.project
-	end
-      end
+    values = {}
 
-      # if the old defect has a requirement
-      if !@object.requirement.nil? && @object.requirement.type == "Story"
-	# get the requiement, copied from this defect's requirement
-	new_story = fetch_object(:artifact, @object.requirement.oid, new_workspace)
-	# update the new defect
-	values[:requirement] = new_story
+    if !@object.requirement.nil?
+      new_requirement = fetch_object(:artifact, @object.requirement.oid)
+      values[:requirement] = new_requirement
+    end
 
-	# if the new defect is in the Parent Project and 
-	# the new requirement is not in the same project as the defect,
-	# then put the defect in the same project as the requirement
-	if new_defect.project.nil? && new_defect.project != new_story.project
-	  values[:project] = new_story.project
-	end
-      end
+    if has_test_case? && has_requirement? && test_cases_work_product != work_product 
+      # no-op. Don't tangle the test_case. This exposes a bug in the system where we can be in an invalid state
+    elsif has_test_case?
+      new_test_case = fetch_object(:test_case, @object.test_case.oid)
+      values[:test_case] = new_test_case
     end
 
     # tangle the duplicate defects
     unless @object.duplicates.nil?
       dups = []
       @object.duplicates.each do |dup|
-	dups << fetch_object(:defect, dup.oid, new_workspace)
+	dups << fetch_object(:defect, dup.oid)
       end
       values[:duplicates] = dups
     end
-    new_defect.update(values) unless values.length == 0
+    @new_object.update(values) unless values.length == 0
+  end
+
+  def work_product
+    @object.requirement
+  end
+
+  def has_test_case?
+    not @object.test_case.nil?
+  end
+
+  def has_requirement?
+    not work_product.nil?
+  end
+
+  def test_cases_work_product
+    return nil unless has_test_case?
+    @object.test_case.work_product
   end
 end

data/lib/translate/copy/feature_copy.rb

@@ -0,0 +1,2 @@
+class FeatureCopy < RequirementCopy
+end

data/lib/translate/copy/object_copy.rb

@@ -1,63 +1,81 @@
 class ObjectCopy
-  def initialize(object)
+  def initialize(object, workspace, card = nil)
     @object = object
+    @card = card
+    @new_workspace = workspace
   end
 
-  def copy(new_workspace, additional_values = {})
+  def copy(additional_values = {})
     unless TranslationStore[@object.oid]
-      values = shallow_copy(@object, new_workspace)
+      logger.info "Copying #{@object.type} -- #{@object.name} -- #{@object.oid}"
+      values = shallow_copy @object
       values.merge! additional_values
 
       values[:workspace] = new_workspace
-      values[:project] = find_project_in_new_workspace(new_workspace)
-    
-      @object.rally_rest.logger.info "Copying #{@object.type} -- #{@object.name}"
-      @new_object = create_object(new_workspace.rally_rest, values)
+      values[:project] = find_project_in_new_workspace unless values[:project]
+
+      @new_object = create_object values
       remember @object, @new_object
     else
-      @new_object = fetch_object(@object.type_as_symbol, @object.oid, new_workspace)
+      @new_object = fetch_object(type_as_symbol, @object.oid)
     end
-    copy_children(new_workspace)
+    copy_children
     @new_object
   end
 
+  def tangle
+    logger.info "Tangle #{@object.type} -- #{@object.name}"
+    @new_object = fetch_object(:artifact, @object.oid)
+  end
+
   def remember old, new
+    logger.debug "rembering #{old.type} : #{old.oid} => #{new.type} => #{new.oid}"
     TranslationStore[old.oid] = new.oid
   end
 
-  def create_object(rally_rest, values)
+  def create_object(values)
     rally_rest.create(@object.type_as_symbol, values)
   end
 
-  def find_project_in_new_workspace(new_workspace)
+  def type_as_symbol
+    @object.type_as_symbol
+  end
+
+  def find_project_in_new_workspace
     # I'm assuming (after talking to nate) that if the project is nil, there there is more then one project in the 
     # workspace. At least for single project workspaces that were migrated for project scoping, this is true.
     if @object.project.nil?
       return nil
     else
-      fetch_project(@object.project.name, new_workspace)
+      fetch_project @object.project.name
     end
   end
 
-  def fetch_project(project_name, workspace)
+  def fetch_project(project_name)
     cached_projects = TranslationStore.instance.projects
     return cached_projects[project_name] if cached_projects.key? project_name
-    project = workspace.rally_rest.find(:project, :workspace => workspace) { equal :name, project_name }.first
+    project = rally_rest.find(:project, :workspace => new_workspace) { equal :name, project_name }.first
     cached_projects[project_name] = project
   end
 
-  def shallow_copy(object, new_workspace)
+  def shallow_copy(object)
     keys_to_exclude = excluded_attributes(object)
     values = object.elements.reject { |key, value| keys_to_exclude.include? key }
-    values.delete(:owner) unless user_exists? @object.owner
+    if !user_exists? object.owner
+      logger.warn "Removing unknown user '#{object.owner}' from a '#{@object.type}' with name '#{@object.name}'. The user no longer exists."
+      values.delete(:owner) 
+    end
 
     # Here we need to fix any deleted custom dropdown values that have been deleted
     values.each do |attribute, value|
-      if @object.typedef.custom_dropdown_attributes.key? attribute
-	attrdef = @object.typedef.custom_dropdown_attributes[attribute]
+      logger.debug "Check values #{attribute} = #{value}"      
+      if object.typedef.custom_dropdown_attributes.key? attribute
+	attrdef = object.typedef.custom_dropdown_attributes[attribute]
+	logger.debug "Check custom dropdown values #{attribute} = #{value}"
+	logger.debug "Check custom dropdown allowed_values = #{attrdef.allowed_values.inspect}"
 	unless attrdef.allowed_values.include? value
 	  values[attribute] = nil 
-	  @object.rally_rest.logger.info "Deleteing #{attribute} = #{value} from @{object.name} because it no longer exists"
+	  logger.warn "Deleting Custom Dropdown value '#{attribute}' = '#{value}' from a '#{@object.type}' with name '#{object.name}' because it no longer exists."
 	end
       end
     end
@@ -65,11 +83,36 @@ class ObjectCopy
     values
   end
 
+  def card_values(card)
+    values = {}
+    project = nil
+    values[:rank] = card.rank 
+    values[:schedule_state] = card.state 
+
+    unless card.iteration.nil?
+      iteration = fetch_object(:iteration, card.iteration.oid)
+      if iteration
+	values[:iteration] = iteration
+	project = iteration.project
+      end
+    end
+
+    unless card.release.nil?
+      release = fetch_object(:release, card.release.oid)
+      if release
+	values[:release] = release
+	project = release.project
+      end
+    end
+    values[:project] = project if project
+    values
+  end
+
   def excluded_attributes(object)
     object.typedef.reference_attributes(true).keys
   end
 
-  def copy_children(new_workspace)
+  def copy_children
   end
 
   def user_exists?(username)
@@ -86,13 +129,28 @@ class ObjectCopy
     end
   end
 
-  def fetch_object(type, oid, workspace)
-    cached_objects = TranslationStore.instance.objects
+  def fetch_object(type, oid)
+    # post-copy, there should always be a new_oid. The new_oid is the oid of the object in the 
+    # new workspace
     new_oid = TranslationStore[oid]
-    return cached_objects[new_oid] if cached_objects.key? oid
-    
-    object = @object.rally_rest.find(type, :workspace => workspace) { equal :object_i_d, new_oid }.first
-    cached_objects[new_oid] = object
+
+    return TranslationStore.instance.objects[new_oid] if TranslationStore.instance.objects.key? new_oid
+    logger.debug "Fetch object: Cache hit failed for new_oid = #{new_oid}"
+
+    object = @object.rally_rest.find(type, :workspace => new_workspace) { equal :object_i_d, new_oid }.first
+    TranslationStore.instance.objects[new_oid] = object
+  end
+
+  def logger
+    rally_rest.logger
+  end
+
+  def rally_rest
+    @object.rally_rest
+  end
+
+  def new_workspace
+    @new_workspace
   end
 
 end

data/lib/translate/copy/requirement_copy.rb

@@ -0,0 +1,50 @@
+class RequirementCopy < ObjectCopy
+
+  def create_object(values)
+    new_object = rally_rest.create(:hierarchical_requirement, values)
+
+    if @object.cards
+      @object.cards.each do |card|
+ 	card.copy(new_workspace, :parent => new_object)
+      end
+    end
+
+    if @object.dependents
+      @object.dependents.each do |dependent|
+	if dependent_in_correct_project? dependent
+	  dependent.copy(new_workspace, :parent => new_object)
+	else
+	  logger.warn "For '#{@object.type}' with name '#{@object.name}' in project '#{project_name @object.project}' not creating child association to dependent of type '#{dependent.type}' with name '#{dependent.name}' in project '#{project_name dependent.project}' because dependent it is in the wrong project."
+	end
+      end
+    end
+
+    new_object
+  end
+
+  def project_name(project)
+    return "Parent Project" if project.nil?
+    project.name
+  end
+
+  def dependent_in_correct_project?(dependent)
+    (in_same_project?(dependent) || in_child_project?(dependent)) && !in_different_child_projects?(dependent)
+  end
+
+  def in_same_project?(dependent)
+    @object.project == dependent.project
+  end
+
+  def in_child_project?(dependent)
+    @object.in_parent_project? && !dependent.in_parent_project?
+  end
+
+  def in_different_child_projects?(dependent)
+    !@object.in_parent_project? && !dependent.in_parent_project? && !in_same_project?(dependent)
+  end
+
+  def type_as_symbol
+    :hierarchical_requirement
+  end
+
+end

data/lib/translate/copy/rest_object.rb

@@ -3,11 +3,11 @@ require 'rally_rest_api'
 
 class RestObject
   def copy(new_workspace, additional_values = {})
-    copy_class.new(self).copy(new_workspace, additional_values)
+    copy_class.new(self.dup, new_workspace).copy(additional_values)
   end
 
   def tangle(new_workspace)
-    copy_class.new(self).tangle(new_workspace)
+    copy_class.new(self, new_workspace).tangle
   end
 
   def excepted_attributes
@@ -21,9 +21,17 @@ class RestObject
     when :test_case : TestCaseCopy
     when :defect : DefectCopy
     when :test_case_result : TestCaseResultCopy
+    when :card : CardCopy
+    when :feature : FeatureCopy
+    when :use_case : UseCaseCopy
+    when :supplemental_requirement : SupplementalRequirementCopy
     else
       ObjectCopy
     end
   end
+
+  def in_parent_project?
+    self.project.nil?
+  end
 end
 

data/lib/translate/copy/story_copy.rb

@@ -1,44 +1,81 @@
-class StoryCopy < ObjectCopy
-  def shallow_copy(object, new_workspace)
-    values = super
-    
-    unless object.cards.nil?
-      values[:rank] = object.cards.first.rank 
-      values[:schedule_state] = object.cards.first.state 
-
-      unless object.cards.first.iteration.nil?
-	iteration_name = object.cards.first.iteration.name
-	iteration = fetch_object(:iteration, object.cards.first.iteration.oid, new_workspace)
-	values[:iteration] = iteration if iteration
-      end
-
-      unless object.cards.first.release.nil?
-	release_name = object.cards.first.release.name
-	release = fetch_object(:release, object.cards.first.release.oid, new_workspace)
-	values[:release] = release if release
-      end
+require 'set'
+require 'active_support/breakpoint'
 
+class StoryCopy < RequirementCopy
+  def shallow_copy(object)
+    values = super
+    if @object.cards && !create_user_story_from_card?
+      logger.debug "Requirement copy only have one card"
+      card_values = card_values(object.cards.first)
+      logger.debug card_values.inspect
+      values.merge! card_values
+      logger.debug values.inspect
     end
     values
   end
 
-  def find_project_in_new_workspace(new_workspace)
+  def create_object(values)
+    new_object = rally_rest.create(:hierarchical_requirement, values)
+ 
+    if @object.cards && create_user_story_from_card?
+      logger.warn "For '#{@object.type}' with name '#{@object.name}' we have created two User Stories in the new workspace because this Story has Test Cases and/or Defects attached to that are in different projects than the project the card was schedule in."
+      @object.cards.first.copy(new_workspace, :parent => new_object)
+    end
+    new_object
+  end
+
+  def find_project_in_new_workspace
     if @object.cards.nil?
       return super
+    elsif create_user_story_from_card?
+      return super
     elsif @object.cards.first.project.nil?
       return super 
     else
-      fetch_project(@object.cards.first.project.name, new_workspace)
+      fetch_project @object.cards.first.project.name
     end
   end
 
-  def create_object(rally_rest, values)
-    rally_rest.create(:hierarchical_requirement, values)
+
+  def copy_children
+    @object.cards.first.tasks.each do |task|
+      task.copy(new_workspace, :work_product => @new_object)
+    end if !@object.cards.nil? && !@object.cards.first.tasks.nil?
+  end
+
+  def create_user_story_from_card?
+    unless defined? @create_user_story_from_card 
+      @create_user_story_from_card = any_test_cases_or_defects_in_different_project_than_card?
+    end
+    @create_user_story_from_card 
+  end
+
+  def any_test_cases_or_defects_in_different_project_than_card?
+    return false unless @object.cards
+    projects = collect_test_case_and_defect_projects
+    return false if projects.length == 0
+    card_project = @object.cards.first.project
+
+    not projects.include? card_project
+  end
+
+  def collect_test_case_and_defect_projects
+    projects = Set.new
+    projects.merge collect_projects_from_test_case
+    projects.merge collect_projects_from_defects
+    projects
+  end
+
+  def collect_projects_from_test_case
+    object = @object
+    results = rally_rest.find(:test_case, :workspace => @object.workspace) { equal :work_product, object }
+    results.map { |tc| tc.project }
+  end
+
+  def collect_projects_from_defects
+    object = @object
+    results = rally_rest.find(:defect, :workspace => @object.workspace) { equal :requirement, object }
+    results.map { |tc| tc.project }
   end
 
-   def copy_children(new_workspace)
-     @object.cards.first.tasks.each do |task|
-       task.copy(new_workspace, :work_product => @new_object)
-     end if !@object.cards.nil? && !@object.cards.first.tasks.nil?
-   end
 end

data/lib/translate/copy/supplemental_requirement_copy.rb

@@ -0,0 +1,2 @@
+class SupplementalRequirementCopy < RequirementCopy
+end

data/lib/translate/copy/test_case_copy.rb

@@ -1,6 +1,6 @@
-
+require 'active_support/breakpoint'
 class TestCaseCopy < ObjectCopy
-  def copy_children(new_workspace)
+  def copy_children
     @object.results.each do |result|
       result.copy(new_workspace, :test_case => @new_object)
     end unless @object.results.nil?
@@ -10,44 +10,23 @@ class TestCaseCopy < ObjectCopy
     end unless @object.steps.nil?
   end
 
-  def tangle(new_workspace)
-    
-    values = {}
-    if  !@object.work_product.nil? && @object.work_product.type == "Story"
-      # if the old test case has a work product
-      new_test_case = fetch_object(:test_case, @object.oid, new_workspace)
-      # get the new test case copied from this testcase
-      new_work_product = fetch_object(:artifact, @object.work_product.oid, new_workspace)
-
-      values[:work_product] = new_work_product
-
-
-      
-      # If the original test_case is in a different project from the stories' card,
-      # then create a new user story, as the parent of this new user story, and make
-      # the work_product on the test case the new parent
-      if @object.work_product != nil && @object.work_product.cards != nil &&  # The TC has a work_product, that is scheduled
-	  @object.project != nil &&                                           # The TC in not in the parent project
-      	  @object.work_product.cards.first.project != @object.project         # The card in in a different project from the test_case
+  def tangle
+    super
 
-	story_name = @object.work_product.name
-	parent_story = new_workspace.rally_rest.create(:hierarchical_requirement, 
-						       :workspace => new_workspace,
-						       :project => nil,
-						       :name => "Parent story for #{story_name} to hold test cases in project #{@object.project.name}")
-	new_work_product.update(:parent => parent_story)
-	values[:work_product] = parent_story
+    if @new_object.nil?
+      logger.debug "Could not find new object for object #{@object.oid} -- #{@object.name}"
+      return
+    end
 
-      # if the new test case is in the Parent Project and 
-      # the new work_product is not in the same project as the test case, 
-      # then put the test case in the same project as the work_product
-      elsif new_test_case.project.nil? && new_test_case.project != new_work_product.project
-	values[:project] = new_work_product.project
-      end
-      
-      
+    values = {}
+    if  !@object.work_product.nil? 
+      # get the new work product copied from this testcase
+      new_work_product = fetch_object(:artifact, @object.work_product.oid)
+      values[:work_product] = new_work_product
       # update the new test case
-      new_test_case.update(values) unless values.length == 0
+      @new_object.update(values) unless values.length == 0
     end
   end
 end
+
+

data/lib/translate/copy/test_case_result_copy.rb

@@ -1,5 +1,5 @@
 class TestCaseResultCopy < ObjectCopy
-  def shallow_copy(object, new_workspace)
+  def shallow_copy(object)
     values = super
     values.delete(:tester) unless user_exists? @object.tester
     values

data/lib/translate/copy/use_case_copy.rb

@@ -0,0 +1,2 @@
+class UseCaseCopy < RequirementCopy
+end

data/lib/translate/translate.rb

@@ -14,10 +14,12 @@ class Translate
     @from_workspace_name = args[:from_workspace]
     @to_workspace_name = args[:to_workspace]
     @logger = args[:logger] if args[:logger]
+#    @logger.level = Logger::DEBUG
   end
 
   def run
-    @slm = RallyRestAPI.new(:base_url => @base_url, :username => @username, :password => @password, :logger => @logger, :parse_collections_as_hash => false)
+    @slm = RallyRestAPI.new(:base_url => @base_url, :username => @username, :password => @password, :logger => @logger)
+    @slm.parse_collections_as_hash = false
 
     @from_workspace = @slm.user.subscription.workspaces.find { |w| w.name == @from_workspace_name } 
     @to_workspace = @slm.user.subscription.workspaces.find { |w| w.name == @to_workspace_name } 
@@ -29,25 +31,48 @@ class Translate
 
     begin 
       # now do the copy
-      [:iteration, :release, :story, :defect, :test_case].each do |type|
-	@slm.find_all(type, :workspace => @from_workspace, :order => [:creation_date, :desc]).each do |o|
+      allowed_copy_types.each do |type|
+	@slm.find_all(type, :workspace => @from_workspace, :order => [:creation_date]).each do |o|
 	  o.copy(@to_workspace)
 	end
       end unless store.copy_finished?
       store.copy_finished!
+      @logger.info "Copy complete. "
 
       # Now tangle the objects
-      [:test_case, :defect].each do |type|
+      allowed_tangle_types.each  do |type|
 	@slm.find_all(type, :workspace => @from_workspace).each do |o|
 	  o.tangle(@to_workspace)
 	end
       end unless store.tangle_finished?
       store.tangle_finished!
+      @logger.info "Tangle complete!"
+      @logger.info "Translation complete. Now run with the -a flag to audit the workspace."
     rescue Exception => e
-      @logger.info "Caught an exception #{e}. Remembering where we were."
-      @logger.info e.backtrace.join("\n")
+      @logger.warn "Caught an exception #{e}. Remembering where we were."
+      @logger.warn e.backtrace.join("\n")
       # Remember where we were if there was a failure
       store.dump
+      raise e
     end
   end
+
+  def allowed_copy_types
+    types = [:iteration, :release, :feature, :use_case, :supplemental_requirement, :story, :defect, :test_case]
+    types.delete :test_case unless allowed? "Test Case"
+    types.delete :defect unless allowed? "Defect"
+    types
+  end
+
+  def allowed_tangle_types
+    types = [:test_case, :defect]
+    types.delete :test_case unless allowed? "Test Case"
+    types.delete :defect unless allowed? "Defect"
+    types
+  end
+
+  def allowed?(type)
+    @from_workspace.type_definitions.find { |td| td.name == type }
+  end
+
 end

data/lib/translate/translation_audit.rb

@@ -2,77 +2,137 @@ require 'active_support'
 
 module TranslationAudit
   def audit
+    logger.info "Auditing Iterations"
+    audit_counts(:iteration, "Iterations")
     all_copied_fields_should_match_for :iteration  
+
+    logger.info "Auditing Releases"
+    audit_counts(:release, "Releases")
     all_copied_fields_should_match_for :release
-    all_copied_fields_should_match_for :defect
-    all_copied_fields_should_match_for :defect, [:last_run]
-    all_copied_fields_should_match_for :test_case_result, [:test_case]
-    compare_each :test_case_result do |old, new|
-      if old.test_case.name != new.test_case.name
-	self.logger.info diff_string(old, new)
-      end
-    end      
 
-    all_copied_fields_should_match_for :test_case_step, [:test_case]
-    compare_each :test_case_step do |old, new|
-      if old.test_case.name != new.test_case.name
-	self.logger.info diff_string(old, new)
-      end
-    end      
-    all_copied_fields_should_match_for :task, [:work_product]
-    compare_each :task do |old, new|
-      next if old.work_product.type != "Story"
-      if old.card.work_product.name != new.work_product.name
-	self.logger.info diff_string(old, new)
+    logger.info "Auditing Test Cases"
+    audit_counts(:test_case, "Test Cases")
+    all_copied_fields_should_match_for(:test_case, [:last_run]) do |old, new|
+      next false unless copy_exists? old, new
+      if !old.work_product.nil?
+	begin
+	  if !equal_ignore_whitespace_and_scheduling old.work_product.name, new.work_product.name
+	    logger.warn "For TestCase '#{old.name}' the TestCase's work product names differ"
+	    logger.warn "  old work product name: #{old.work_product.name}"
+	    logger.warn "  new work product name: #{new.work_product.name}"
+	  end
+	rescue Exception => e
+	  raise Exception.new("For test_case #{old.name} -- #{old.oid}, the new test_case had no work product")
+	end
       end
     end
 
-    compare_each :defect do |old, new|
-      if !old.requirement.nil? && old.requirement.type == "Story"
-	if new.requirement.children
-	  if old.requirement.name != new.requirement.children.first.name
-	  end
-	else
-	  if old.requirement.name != new.requirement.name
+    logger.info "Auditing Defects"
+    audit_counts(:defect, "Defects")
+    all_copied_fields_should_match_for(:defect, [:closed_date, :submitted_by]) do |old, new|
+      next false unless copy_exists? old, new
+      if !old.requirement.nil?
+	begin 
+	  if !equal_ignore_whitespace_and_scheduling old.requirement.name, new.requirement.name
+	    logger.warn "For Defect '#{old.name}' the Defect's requirement names differ"
+	    logger.warn "  old requirement name: #{old.requirement.name}"
+	    logger.warn "  new requirement name: #{new.requirement.name}"
 	  end
+	rescue Exception => e
+	  raise Exception.new("For defect #{old.name}, the new defect had no requirement")
 	end
       end
     end
 
-    compare_each :test_case do |old, new|
-      if !old.work_product.nil? && old.work_product.type == "Story"
-	if new.work_product.children
-	  if old.work_product.name != new.work_product.children.first.name
-	  end
-	else
-	  if old.work_product.name != new.work_product.name
-	  end
-	end
+    logger.info "Auditing Test Case Results"
+    audit_counts(:test_case_result, "Test Case Results")
+    all_copied_fields_should_match_for(:test_case_result, [:test_case, :tester]) do |old, new|
+      next false unless copy_exists? old, new
+      if !equal_ignore_whitespace_and_scheduling old.test_case.name, new.test_case.name
+	logger.warn "For Test Case Result '#{old.name}' the test case names differ"
+	logger.warn "  old test case name: #{old.test_case.name}"
+	logger.warn "  new test case name: #{new.test_case.name}"
+      end
+    end      
+
+    logger.info "Auditing Test Case Steps"
+    audit_counts(:test_case_step, "Test Case Steps")
+    all_copied_fields_should_match_for(:test_case_step, [:test_case]) do |old, new|
+      next false unless copy_exists? old, new
+      if !equal_ignore_whitespace_and_scheduling old.test_case.name, new.test_case.name
+	logger.warn "For Test Case Step '#{old.name}' the test case names differ"
+	logger.warn "  old test case name: #{old.test_case.name}"
+	logger.warn "  new test case name: #{new.test_case.name}"
+      end
+    end      
 
+    logger.info "Auditing Tasks"
+    audit_counts(:task, "Tasks")
+    all_copied_fields_should_match_for(:task, [:work_product]) do |old, new|
+      next false unless copy_exists?(old, new) do |old_object, new_object|
+	logger.warn "  task belongs to a '#{old_object.card.work_product.type}' with name '#{old_object.card.work_product.name}'" 
       end
+      if !equal_ignore_whitespace_and_scheduling old.card.work_product.name, new.work_product.name
+	logger.warn "For Task '#{old.name}' the work product names differ"
+	logger.warn "  old work product name: #{old.card.work_product.name}"
+	logger.warn "  new work product name: #{new.work_product.name}"
+      end
+    end
+
+    logger.info "Auditing Features"
+    compare_each :feature, :hierarchical_requirement do |old, new|
+      return false unless copy_exists? old, new
     end
+
+    logger.info "Audit complete!"
+  end
+
+  def audit_counts(type, type_string)
+    source_count = @slm.find_all(type, :workspace => @from_workspace).total_result_count
+    dest_count = @slm.find_all(type, :workspace => @to_workspace).total_result_count
+    logger.warn("Auditing #{type_string} counts:")
+    logger.warn("  #{source_count} #{type_string} found in workspace '#{@from_workspace.name}'")
+    logger.warn("  #{dest_count} #{type_string} found in workspace '#{@to_workspace.name}'")
   end
 
-  def compare_each(type)
+  def compare_each(type, new_type = type)
     @slm.find_all(type, :workspace => @from_workspace).each do |old_object|
-      new_object = @slm.find(type, :workspace => @to_workspace) { equal :object_i_d, TranslationStore[old_object.oid] }.first
-      if new_object.nil?
-	self.logger.info "Cound not find a copy for object #{old_object.type} -- #{old_object.name} -- #{old_object.oid}"
-	next
-      end
+      new_object = @slm.find(new_type, :workspace => @to_workspace) { equal :object_i_d, TranslationStore[old_object.oid] }.first
       yield old_object, new_object
     end
   end
 
+  def copy_exists?(old_object, new_object)
+    if new_object.nil?
+      self.logger.warn "Cound not find a copy for object #{old_object.type} -- #{old_object.name} -- #{old_object.oid}"
+      yield old_object, new_object if block_given?
+      return false
+    end
+    true
+  end
+
   def all_copied_fields_should_match_for(type, additional_exceptions = [])
+    additional_exceptions << :creation_date
     compare_each(type) do |old_object, new_object| 
+      next unless yield old_object, new_object if block_given?
       diff = diff_objects(old_object, new_object, additional_exceptions)
       if diff.length > 0
-	self.logger.info diff_string(old_object, new_object, additional_exceptions)
+	self.logger.warn diff_string(old_object, new_object, additional_exceptions)
       end
     end
   end
 
+  def diff_string(old, new, additional_exceptions = [])
+    diff = diff_objects(old, new, additional_exceptions)
+
+    diff_string = "#{old.type} with name '#{old.name}' -- #{old.oid}:#{new.oid} differs\n"
+    diff_string << "value\told\t\t\t\tnew\n"
+    diff.each do |key, valye|
+      diff_string << key.to_s << "\t" << old.elements[key].to_s << "\t\t\t" << new.elements[key].to_s << "\n"
+    end
+    diff_string
+  end
+
   def diff_objects(old_object, new_object, additional_exceptions = [])
     excepted_attributes = old_object.excepted_attributes + additional_exceptions
     old_hash = old_object.elements.reject { |k, v| excepted_attributes.include?(k) }
@@ -84,14 +144,13 @@ module TranslationAudit
     old_hash.diff(new_hash)
   end
 
-  def diff_string(old, new, additional_exceptions = [])
-    diff = diff_objects(old, new, additional_exceptions)
-    diff_string = "#{old.type} with name '#{old.name}' differs\n"
-    diff_string << "\told\t\t\tnew\n"
-    diff.each do |key, valye|
-      diff_string << "\t" << old.elements[key] << "\t\t\t" << new.elements[key] << "\n"
-    end
-    diff_string << "\n"
-    diff_string
+  def equal_ignore_whitespace_and_scheduling(s1, s2)
+    normalized_string(s1) == normalized_string(s2)
   end
+
+  def normalized_string(s)
+    scheduled_string = "Scheduled child of "
+    s.strip.squeeze(" ").gsub(scheduled_string, "")
+  end
+
 end

data/lib/translate/version.rb

@@ -2,7 +2,7 @@ module Translate #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 0
-    TINY  = 4
+    TINY  = 6
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: rally_workspace_utils
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
-date: 2007-01-03 00:00:00 -07:00
+  version: 0.0.6
+date: 2007-02-06 00:00:00 -07:00
 summary: A utility to translate a UseCase workspace to a UserStory workspace
 require_paths: 
 - lib
@@ -43,7 +43,12 @@ files:
 - lib/translate/copy/story_copy.rb
 - lib/translate/copy/test_case_result_copy.rb
 - lib/translate/copy/defect_copy.rb
+- lib/translate/copy/feature_copy.rb
+- lib/translate/copy/use_case_copy.rb
+- lib/translate/copy/supplemental_requirement_copy.rb
+- lib/translate/copy/card_copy.rb
 - lib/translate/copy/object_copy.rb
+- lib/translate/copy/requirement_copy.rb
 - lib/translate/copy/test_case_copy.rb
 - lib/translate/translation_store.rb
 - test/translation_store_spec.rb
@@ -69,7 +74,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.6.3
+        version: 0.6.4
     version: 
 - !ruby/object:Gem::Dependency 
   name: activesupport