translate 0.0.1

data/Manifest.txt

@@ -0,0 +1,17 @@
+Manifest.txt
+README.txt
+Rakefile
+setup.rb
+test/test_helper.rb
+test/translate_test.rb
+bin/translate
+lib/translate/copy.rb
+lib/translate/version.rb
+lib/translate/translate.rb
+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/object_copy.rb
+lib/translate/copy/test_case_copy.rb
+lib/translate.rb

data/README.txt

@@ -0,0 +1,3 @@
+README for translate
+====================
+

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require 'hoe'
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'translate', 'version')
+
+AUTHOR = "bcotton"  # can also be an array of Authors
+EMAIL = "bcotton@rallydev.com"
+DESCRIPTION = "A utility to translate a UseCase workspace to a UserStory workspace"
+GEM_NAME = "translate" # what ppl will type to install your gem
+RUBYFORGE_PROJECT = "rally-rest-api" # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+RELEASE_TYPES = %w( gem ) # can use: gem, tar, zip
+
+
+NAME = "translate"
+REV = nil # UNCOMMENT IF REQUIRED: File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+VERS = ENV['VERSION'] || (Translate::VERSION::STRING + (REV ? ".#{REV}" : ""))
+CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = ['--quiet', '--title', "translate documentation",
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/*_test.rb"]
+  p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
+
+  p.extra_deps = []
+  p.extra_deps << ["rally_rest_api", ">= 0.6.1"]
+
+  
+  # == Optional
+  #p.changes        - A description of the release's latest changes.
+  #p.extra_deps     - An array of rubygem dependencies.
+  #p.spec_extras    - A hash of extra values to set in the gemspec.
+end
+          

data/bin/translate

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+

data/lib/translate.rb

@@ -0,0 +1,2 @@
+require 'translate/translate'
+

data/lib/translate/copy.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'rally_rest_api'
+
+require 'translate/copy/rest_object'
+require 'translate/copy/object_copy'
+require 'translate/copy/defect_copy'
+require 'translate/copy/story_copy'
+require 'translate/copy/test_case_copy'
+require 'translate/copy/test_case_result_copy'

data/lib/translate/copy/defect_copy.rb

@@ -0,0 +1,75 @@
+class DefectCopy < ObjectCopy
+
+  def shallow_copy(object, new_workspace)
+
+    values = super
+    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
+
+      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 #{story_name} to hold defects in project #{@object.project.name}")
+      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 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
+
+      # 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 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
+    end
+
+    # tangle the duplicate defects
+    unless @object.duplicates.nil?
+      dups = []
+      @object.duplicates.values.each do |dup|
+	dups << fetch_object(:defect, dup.oid, new_workspace)
+      end
+      values[:duplicates] = dups
+    end
+    new_defect.update(values) unless values.length == 0
+  end
+end

data/lib/translate/copy/object_copy.rb

@@ -0,0 +1,97 @@
+require 'pp'
+
+class ObjectCopy
+  def initialize(object)
+    @object = object
+  end
+
+  def copy(new_workspace, additional_values = {})
+    values = shallow_copy(@object, new_workspace)
+    values.merge! additional_values
+
+    values[:workspace] = new_workspace
+    values[:project] = find_project_in_new_workspace(new_workspace)
+    
+    @new_object = create_object(new_workspace.rally_rest, values)
+    remember @object, @new_object
+    copy_children(new_workspace)
+
+    @new_object
+  end
+
+  def remember old, new
+    $TRANSLATED ||= {}
+    $TRANSLATED[old.oid] = new.oid
+  end
+
+  def create_object(rally_rest, values)
+    rally_rest.create(@object.type_as_symbol, values)
+  end
+
+  def find_project_in_new_workspace(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)
+    end
+  end
+
+  def fetch_project(project_name, workspace)
+    @@cached_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
+    @@cached_projects[project_name] = project
+  end
+
+  def shallow_copy(object, new_workspace)
+    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
+
+    # 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]
+	unless attrdef.allowed_values.include? value
+	  values[attribute] = nil 
+	  puts "Deleteing #{attribute} = #{value} from @{object.name} because it no longer exists"
+	end
+      end
+    end
+
+    values
+  end
+
+  def excluded_attributes(object)
+    object.typedef.reference_attributes(true).keys
+  end
+
+  def copy_children(new_workspace)
+  end
+
+  def user_exists?(username)
+    @@cached_users ||= {}
+
+    return true if username.nil?
+    return @@cached_users[username] if @@cached_users.key? username
+
+    result = @object.rally_rest.find(:user) { equal :login_name, username }
+    if result.total_result_count > 0
+      @@cached_users[username] = true
+    else
+      @@cached_users[username] = false
+    end
+  end
+
+  def fetch_object(type, oid, workspace)
+    @@cached_objects ||= {}
+    new_oid = $TRANSLATED[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
+  end
+end
+

data/lib/translate/copy/rest_object.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'rally_rest_api'
+
+class RestObject
+  def copy(new_workspace, additional_values = {})
+    copy_class.new(self).copy(new_workspace, additional_values)
+  end
+
+  def tangle(new_workspace)
+    copy_class.new(self).tangle(new_workspace)
+  end
+
+  def excepted_attributes
+    [:object_id, :creation_date, :formatted_id, :owner] + self.typedef.reference_attributes(true).keys + self.typedef.custom_dropdown_attributes.keys
+  end
+
+  def copy_class
+    case self.type_as_symbol
+    when :card : CardCopy
+    when :story : StoryCopy
+    when :test_case : TestCaseCopy
+    when :defect : DefectCopy
+    when :test_case_result : TestCaseResultCopy
+    else
+      ObjectCopy
+    end
+  end
+end
+

data/lib/translate/copy/story_copy.rb

@@ -0,0 +1,44 @@
+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
+
+    end
+    values
+  end
+
+  def find_project_in_new_workspace(new_workspace)
+    if @object.cards.nil?
+      return super
+    elsif @object.cards.first.project.nil?
+      return super 
+    else
+      fetch_project(@object.cards.first.project.name, new_workspace)
+    end
+  end
+
+  def create_object(rally_rest, values)
+    rally_rest.create(:hierarchical_requirement, values)
+  end
+
+   def copy_children(new_workspace)
+     @object.cards.first.tasks.values.flatten.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/test_case_copy.rb

@@ -0,0 +1,53 @@
+
+class TestCaseCopy < ObjectCopy
+  def copy_children(new_workspace)
+    @object.results.each do |result|
+      result.copy(new_workspace, :test_case => @new_object)
+    end unless @object.results.nil?
+
+    @object.steps.each do |step|
+      step.copy(new_workspace, :test_case => @new_object)
+    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
+
+	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 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
+      
+      
+      # update the new test case
+      new_test_case.update(values) unless values.length == 0
+    end
+  end
+end

data/lib/translate/copy/test_case_result_copy.rb

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

data/lib/translate/translate.rb

@@ -0,0 +1,60 @@
+require 'translate/copy'
+
+class Translate
+  def initialize(args)
+    @base_url = args[:base_url]
+    @username = args[:username]
+    @password = args[:password]
+    @from_workspace_name = args[:from]
+    @to_workspace_name = args[:to]
+  end
+
+  def run
+    @slm = RallyRestAPI.new(:base_url => @base_url, :username => @username, :password => @password)
+
+    @workspace1 = @slm.user.subscription.workspaces.values.flatten.find { |w| w.name == @from_workspace_name } 
+    @workspace2 = @slm.user.subscription.workspaces.values.flatten.find { |w| w.name == @to_workspace_name } 
+
+    raise "No such workspace #{@from_workspace_name}" unless @workspace1
+    raise "No such workspace #{@to_workspace_name}" unless @workspace2
+    $TRANSLATED[:from] = @from_workspace_name
+    $TRANSLATED[:to] = @to_workspace_name
+
+    if File::exists? "TRANSLATED"
+      File.open("TRANSLATED", "r") do |f|
+	$TRANSLATED = Marshal.load(f)
+      end
+      puts "Read TRANSLATED"
+    end
+
+    # now do the copy
+    [:iteration, :release, :story, :defect, :test_case].each do |type|
+      @slm.find_all(type, :workspace => @workspace1).each do |o|
+	puts "Copying #{o.type} -- #{o.name}"
+	o.copy(@workspace2)
+      end
+    end unless $TRANSLATED[:copy]
+    # mark these workspaces as copied
+    $TRANSLATED[:copy] = true
+    # dump the oids to disk
+    dump_oids
+
+    # Now tangle the objects
+    [:test_case, :defect].each do |type|
+      @slm.find_all(type, :workspace => @workspace1).each do |o|
+	puts "Tangle #{o.type} -- #{o.name}"
+	o.tangle(@workspace2)
+      end
+    end unless $TRANSLATED[:tangle]
+    
+    $TRANSLATED[:tangle] = true
+    dump_oids
+  end
+
+  def dump_oids
+    File.open("TRANSLATED", "w+") do |f|
+      Marshal.dump($TRANSLATED, f)
+    end
+  end
+
+end