zerg_xcode 0.1 → 0.2

data/CHANGELOG

@@ -1 +1,3 @@
+v0.2. Implemented import.
+
 v0.1. Initial release. Knows help, irb, ls, retarget.

data/Manifest

@@ -6,8 +6,12 @@ lib/zerg_xcode/file_format/lexer.rb
 lib/zerg_xcode/file_format/parser.rb
 lib/zerg_xcode/file_format/paths.rb
 lib/zerg_xcode/objects/pbx_build_file.rb
+lib/zerg_xcode/objects/pbx_container_item_proxy.rb
+lib/zerg_xcode/objects/pbx_group.rb
 lib/zerg_xcode/objects/pbx_native_target.rb
 lib/zerg_xcode/objects/pbx_project.rb
+lib/zerg_xcode/objects/pbx_target_dependency.rb
+lib/zerg_xcode/objects/xc_configuration_list.rb
 lib/zerg_xcode/objects/xcode_object.rb
 lib/zerg_xcode/plugins/core/core.rb
 lib/zerg_xcode/plugins/help.rb
@@ -28,8 +32,12 @@ test/file_format/lexer_test.rb
 test/file_format/parser_test.rb
 test/file_format/path_test.rb
 test/objects/pbx_build_file_test.rb
+test/objects/pbx_container_item_proxy_test.rb
+test/objects/pbx_group_test.rb
 test/objects/pbx_native_target_test.rb
 test/objects/pbx_project_test.rb
+test/objects/pbx_target_dependency_test.rb
+test/objects/xc_configuration_list_test.rb
 test/objects/xcode_object_test.rb
 test/plugins/core/core_test.rb
 test/plugins/import_test.rb
@@ -38,6 +46,7 @@ test/plugins/ls_test.rb
 test/plugins/retarget_test.rb
 test/plugins/test_helper.rb
 test/shortcuts_test.rb
+testdata/FlatTestApp/FlatTestApp.xcodeproj/project.pbxproj
 testdata/project.pbxproj
 testdata/project.pbxproj.compat
 testdata/TestApp/TestApp.xcodeproj/project.pbxproj

data/RUBYFORGE

@@ -1,6 +1,6 @@
 Quickstart for Rubyforge:
 
-1) Checkout the zergxcode code
+1) Get the code
 git clone git@github.com:costan/zerg_xcode.git
 
 2) Install the rubyforge gem
@@ -30,7 +30,7 @@ Releasing a new gemspec to Github
 rake package
 
 2) Copy the spec
-cp pkg/zerg_xcode-0.1/zerg_xcode.gemspec .
+cp pkg/zerg_xcode-*/zerg_xcode.gemspec .
 
 3) Commit the spec
 git add zerg_xcode.gemspec

data/lib/zerg_xcode/objects/pbx_container_item_proxy.rb

@@ -0,0 +1,10 @@
+# Proxy for another object.
+#
+# Unsure these are useful, since each object has an unique ID. They are probably
+# implementation artifacts.
+class ZergXcode::Objects::PBXContainerItemProxy < ZergXcode::XcodeObject
+  # The proxied object.
+  def target
+    self['remoteGlobalIDString']
+  end
+end

data/lib/zerg_xcode/objects/pbx_group.rb

@@ -0,0 +1,3 @@
+# A group of files.
+class ZergXcode::Objects::PBXGroup < ZergXcode::XcodeObject
+end

data/lib/zerg_xcode/objects/pbx_project.rb

@@ -3,12 +3,23 @@ class ZergXcode::Objects::PBXProject < ZergXcode::XcodeObject
   # Used to implement save!
   attr_accessor :source_filename
   
+  # :nodoc: override to copy the new metadata
+  def copy_metadata(source)
+    super
+    self.source_filename = source.source_filename
+  end
+
   # Saves a project that was loaded by ZergXcode.load
   def save!
     raise 'Project not loaded by ZergXcode.load' unless @source_filename
     ZergXcode.dump self, @source_filename
   end
   
+  # The root path of the project.
+  def root_path
+    ZergXcode::Paths.project_root_at source_filename
+  end
+  
   # All the files referenced by the project.
   def all_files
     files = []

data/lib/zerg_xcode/objects/pbx_target_dependency.rb

@@ -0,0 +1,7 @@
+# Expresses a target's dependency on another target.
+class ZergXcode::Objects::PBXTargetDependency < ZergXcode::XcodeObject
+  # The target that this target depends on.
+  def target
+    self['target']
+  end
+end

data/lib/zerg_xcode/objects/xc_configuration_list.rb

@@ -0,0 +1,3 @@
+# The configurations associated with an object.
+class ZergXcode::Objects::XCConfigurationList < ZergXcode::XcodeObject
+end

data/lib/zerg_xcode/objects/xcode_object.rb

@@ -71,6 +71,16 @@ class ZergXcode::XcodeObject
     visit_hash(@attrs, &accept)
     self
   end
+  
+  # Convenience method mapping over visit and exploring each object once.
+  def visit_once(&accept)
+    visited = Set.new([self])
+    self.visit do |object, parent, key, value|
+      visited << object
+      next_value = yield object, parent, key, value
+      visited.include?(value) ? false : next_value
+    end
+  end
 
   def visit_hash(hash, &accept)
     hash.each_key do |key|
@@ -137,8 +147,12 @@ class ZergXcode::XcodeObject
   
   def shallow_copy
     new_object = self.class.new @attrs.dup
-    new_object.version, new_object.archive_id = version, archive_id
+    new_object.copy_metadata self
     return new_object
-  end  
+  end
+  
+  def copy_metadata(source)
+    self.archive_id, self.version = source.archive_id, source.version 
+  end
 end
 

data/lib/zerg_xcode/plugins/import.rb

@@ -1,4 +1,9 @@
+require 'fileutils'
+require 'pathname'
+
 class ZergXcode::Plugins::Import
+  include ZergXcode::Objects
+  
   def help
     {:short => 'imports the objects from a project into another project',
      :long => <<"END" }
@@ -14,6 +19,306 @@ END
     source = ZergXcode.load args.shift
     target = ZergXcode.load(args.shift || '.')
     
-    print "Import is not yet implemented."
+    file_ops = import_project! source, target
+    target.save!
+    execute_file_ops! file_ops 
+  end
+  
+  # Executes the given file operations.
+  def execute_file_ops!(file_ops)
+    file_ops.each do |op|
+      case op[:op]
+      when :delete
+        FileUtils.rm_r op[:path] if File.exist? op[:path]
+      when :copy
+        target_dir = File.dirname op[:to]
+        FileUtils.mkdir_p  target_dir unless File.exist? target_dir
+        if File.exist? op[:from]
+          FileUtils.cp_r op[:from], op[:to]
+        else
+          print "Source does not have file #{op[:from]}\n"
+        end
+      end
+    end
+  end
+  
+  # Imports the objects of the source project into the target project.
+  # 
+  # Attempts to preserve reference integrity in the target project, as follows.
+  # If the source objects have counterparts in the target, their contents is
+  # merged into the target project's objects.
+  #
+  # Returns an array of file operations that need to be performed to migrate the
+  # files associated with the two projects.
+  #
+  # The target project is modified in place.
+  def import_project!(source, target)
+    old_target_paths = target.all_files.map { |file| file[:path] } 
+    
+    # duplicate the source, because the duplicate's object graph will be warped
+    scrap_source = ZergXcode::XcodeObject.from source
+    
+    mappings = cross_reference scrap_source, target
+    bins = bin_mappings mappings, scrap_source
+    
+    # special case for merging targets
+    map! scrap_source, mappings
+    merge! scrap_source['targets'], target['targets']
+    
+    # merge the object graphs
+    bins[:merge].each do |object|
+      map! object, mappings
+      merge! object, mappings[object]
+    end
+    bins[:overwrite].each do |object|
+      map! object, mappings
+      overwrite! object, mappings[object]
+    end
+    
+    # make sure all the mappings point in the right place 
+    target.visit_once do |object, parent, key, value|
+      if mappings[value]
+        next mappings[value]
+      else
+        next true
+      end
+    end
+    
+    new_target_paths = target.all_files.map { |file| file[:path] }
+    source_paths = source.all_files.map { |file| file[:path] }
+    return compute_deletes(target.root_path, old_target_paths,
+                           new_target_paths) +
+           compute_copies(source.root_path, source_paths, target.root_path)
+  end
+
+  # Computes the file delete operations in a merge.
+  #
+  # Deletes all the files that aren't in the target project anymore. 
+  def compute_deletes(root, old_paths, new_paths)
+    new_path_set = Set.new(new_paths)
+    old_paths.select { |path| path[0, 2] == './' }.
+              reject { |path| new_path_set.include? path }.
+              map { |path| { :op => :delete, :path => clean_join(root, path) } }
+  end
+
+  # Computes the file copy operations in a merge.
+  #
+  # Copies all the files from the source project assuming they received the same
+  # path in the target project. The assumption is correct if source was imported
+  # into target.
+  def compute_copies(source_root, source_paths, target_root)
+    source_paths.select { |path| path[0, 2] == './' }.map do |path|
+      { :op => :copy, :from => clean_join(source_root, path),
+        :to => clean_join(target_root, path) }
+    end
+  end
+  
+  def clean_join(root, path)
+    Pathname.new(File.join(root, path)).cleanpath.to_s
+  end
+  
+  # Bins merge mappings for a project into mappings to be merged and mappings to
+  # be overwritten.
+  def bin_mappings(mappings, source)
+    merge_set = Set.new
+    overwrite_set = Set.new
+
+    # the project's top-level attributes are always merged
+    source.attrs.each do |attr|
+      merge_set << source[attr] if mappings[source[attr]]
+    end
+        
+    mappings.each do |source_object, target_object|
+      next if source_object == target_object
+      next if merge_set.include? source_object
+      
+      if source_object.kind_of?(PBXGroup) && source_object['path'].nil?
+        merge_set << source_object
+      elsif source_object.kind_of? XCConfigurationList
+        merge_set << source_object
+      else
+        overwrite_set << source_object
+      end
+    end
+    
+    overwrite_set.delete source
+    { :merge => merge_set, :overwrite => overwrite_set }
+  end
+  
+  # Modifies an object's attributes according to the given mappings.
+  # This explores the object graph, but does not go into sub-objects.
+  def map!(object, mappings)
+    object.visit_once do |object, parent, key, value|
+      if mappings[value]
+        parent[key] = mappings[value]
+        next false
+      end
+      next true
+    end
+  end
+  
+  # Merges the contents of a source object into the target object.
+  #
+  # Warning: the target will share internal objects with the source. This is
+  # intended to be used in a bigger-level opration, where the source will be
+  # thrown away afterwards.
+  def merge!(source, target)
+    if source.class != target.class
+      raise "Attempting to merge-combine different kinds of objects - " +
+            "#{source.class} != #{target.class}"
+    end
+    
+    case source
+    when ZergXcode::XcodeObject
+      merge! source._attr_hash, target._attr_hash
+    when Hash
+      source.each_key do |key|
+        if !target.has_key?(key)
+          target[key] = source[key]          
+        elsif source[key].kind_of? ZergXcode::XcodeObject
+          target[key] = source[key]
+        elsif source[key].kind_of?(String)
+          target[key] = source[key]
+        elsif !source[key].kind_of?(Enumerable)
+          target[key] = source[key]
+        else
+          merge! source[key], target[key]
+        end
+      end
+    when Enumerable
+      target_set = Set.new(target.to_a)
+      source.each do |value|
+        next if target_set.include? value
+        target << value
+      end
+    end   
+  end
+  
+  # Overwrites the contents of the target object with the source object.
+  #
+  # Warning: the target will share internal objects with the source. This is
+  # intended to be used in a bigger-level opration, where the source will be
+  # thrown away afterwards.  
+  def overwrite!(source, target)
+    if source.class != target.class    
+      raise "Attempting to overwrite-combine different kinds of objects - " +
+            "#{source.class} != #{target.class}"
+    end
+    
+    case source
+    when ZergXcode::XcodeObject
+      overwrite! source._attr_hash, target._attr_hash
+    when Hash
+      target.clear
+      target.merge! source
+    when Enumerable
+      target.clear
+      source.each { |value| target << value }      
+    end
+  end
+  
+  # Cross-references the objects in two object graphs that are to be merged.
+  # Returns a Hash associating objects in both the source and the target object
+  # graphs with the corresponding objects in the 
+  def cross_reference(source, target, mappings = {})
+    if source.class != target.class
+      raise "Attempting to cross-reference different kinds of objects - " +
+            "#{source.class} != #{target.class}"
+    end
+    
+    case target
+    when ZergXcode::XcodeObject
+      cross_op = :cross_reference_objects
+    when Hash
+      cross_op = :cross_reference_hashes
+    when Enumerable
+      cross_op = :cross_reference_enumerables
+    else
+      return mappings
+    end
+    
+    self.send cross_op, source, target, mappings
+  end
+    
+  def cross_reference_objects(source, target, mappings)
+    return mappings if mappings[source] || mappings[target]    
+    return mappings if source.xref_key != target.xref_key
+    
+    mappings[target] = target
+    mappings[source] = target
+    cross_reference source._attr_hash, target._attr_hash, mappings
+  end
+  private :cross_reference_objects
+  
+  def cross_reference_hashes(source, target, mappings)
+    source.each_key do |key|
+      p [source.keys, key] if source[key].nil? 
+      cross_reference source[key], target[key], mappings if target[key]
+    end
+    mappings
+  end
+  private :cross_reference_hashes
+  
+  def cross_reference_enumerables(source, target, mappings)
+    source_keys = {}
+    source.each do |value|
+      next unless value.kind_of? ZergXcode::XcodeObject
+      source_keys[value.xref_key] = value
+    end
+    target.each do |value|
+      next unless value.kind_of? ZergXcode::XcodeObject
+      next unless source_value = source_keys[value.xref_key]
+      cross_reference source_value, value, mappings
+    end
+    mappings
+  end
+  private :cross_reference_enumerables  
+end
+
+class ZergXcode::XcodeObject
+  def xref_key
+    # If the object doesn't have a merge name, use its (unique) object_id.
+    [isa, xref_name || object_id]
+  end
+  
+  def xref_name
+    # Do not use this to override xref_name for specific objects. Only use
+    # it for object families.
+    case isa.to_s
+    when /BuildPhase$/
+      isa.to_s
+    else
+      self['name'] || self['explicitPath'] || self['path'] 
+    end
+  end  
+end
+
+class ZergXcode::Objects::PBXBuildFile
+  def xref_name
+    self['fileRef'].xref_name
+  end
+end
+
+class ZergXcode::Objects::PBXProject
+  def xref_name
+    isa.to_s
+  end
+end
+
+class ZergXcode::Objects::XCConfigurationList
+  def xref_name
+    isa.to_s
+  end
+end
+
+class ZergXcode::Objects::PBXContainerItemProxy
+  def xref_name
+    self['remoteInfo']
+  end
+end
+
+class ZergXcode::Objects::PBXTargetDependency
+  def xref_name
+    target.xref_name
   end
 end

data/lib/zerg_xcode.rb

@@ -10,8 +10,12 @@ require 'zerg_xcode/file_format/paths.rb'
 
 require 'zerg_xcode/objects/xcode_object.rb'
 require 'zerg_xcode/objects/pbx_build_file.rb'
+require 'zerg_xcode/objects/pbx_container_item_proxy.rb'
+require 'zerg_xcode/objects/pbx_group.rb'
 require 'zerg_xcode/objects/pbx_native_target.rb'
 require 'zerg_xcode/objects/pbx_project.rb'
+require 'zerg_xcode/objects/pbx_target_dependency.rb'
+require 'zerg_xcode/objects/xc_configuration_list.rb'
 require 'zerg_xcode/plugins/core/core.rb'
 
 require 'zerg_xcode/shortcuts.rb'

data/test/objects/pbx_container_item_proxy_test.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+
+require 'zerg_xcode'
+
+class PBXContainerItemProxyTest < Test::Unit::TestCase
+  PBXContainerItemProxy = ZergXcode::Objects::PBXContainerItemProxy
+  
+  def test_target
+    proj = ZergXcode.load 'testdata/ZergSupport.xcodeproj/project.pbxproj'    
+    proxy = proj['targets'][2]['dependencies'].first['targetProxy']
+    assert_equal PBXContainerItemProxy, proxy.class
+    assert_equal proj['targets'][1], proxy.target
+  end
+end

data/test/objects/pbx_group_test.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+
+require 'zerg_xcode'
+
+class PBXGroupTest < Test::Unit::TestCase
+  PBXGroup = ZergXcode::Objects::PBXGroup
+  
+  def test_instantiation
+    proj = ZergXcode.load 'testdata/project.pbxproj'
+    assert_equal PBXGroup, proj['mainGroup'].class
+  end
+end

data/test/objects/pbx_project_test.rb

@@ -59,4 +59,16 @@ class PBXProjectTest < Test::Unit::TestCase
                         and_return(nil)
     project.save!
   end
+  
+  def test_root_path
+    project = ZergXcode.load('testdata/ZergSupport.xcodeproj') 
+    assert_equal 'testdata', project.root_path
+  end
+  
+  def test_copy_metadata
+    project = ZergXcode.load('testdata/ZergSupport.xcodeproj')
+    clone = ZergXcode::XcodeObject.from project
+    
+    assert_equal project.source_filename, clone.source_filename
+  end
 end

data/test/objects/pbx_target_dependency_test.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+
+require 'zerg_xcode'
+
+class PBXTargetDependencyTest < Test::Unit::TestCase
+  PBXTargetDependency = ZergXcode::Objects::PBXTargetDependency
+  
+  def test_target
+    proj = ZergXcode.load 'testdata/ZergSupport.xcodeproj/project.pbxproj'    
+    dependency = proj['targets'][2]['dependencies'].first
+    assert_equal PBXTargetDependency, dependency.class
+    assert_equal proj['targets'][1], dependency.target
+  end
+end

data/test/objects/xc_configuration_list_test.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+
+require 'zerg_xcode'
+
+class XCConfigurationListTest < Test::Unit::TestCase
+  XCConfigurationList = ZergXcode::Objects::XCConfigurationList
+  
+  def test_instantiation
+    proj = ZergXcode.load 'testdata/project.pbxproj'
+    assert_equal XCConfigurationList, proj['buildConfigurationList'].class
+  end
+end

data/test/objects/xcode_object_test.rb

@@ -46,6 +46,32 @@ class ObjectTest < Test::Unit::TestCase
     assert_equal golden_visited.sort, visited.sort
   end
   
+  def test_visit_once
+    golden_visited = [
+      [49, 'sub1', @sub1],      
+      [39, 'array', @sub1[:array]],
+      [39, '0', 'a'],
+      [39, '1', 'b'],
+      [39, '2', 'c'],
+      [39, 'string', 's'],
+      [39, 'root', @root],
+      [49, 'sub2', @sub2],
+      [42, 'hash', @sub2[:hash]],
+      [42, 'k', 'v'],
+      [42, 'k2', 'v2'],
+      [42, 'sub1', @sub1],
+    ]
+    @sub1['root'] = @root
+    
+    visited = []
+    @root.visit_once do |object, parent, key, value|
+      assert_equal value, parent[key], 'Parent/Key/Value check'
+      visited << [object.archive_id, key.to_s, value]
+      next true
+    end
+    assert_equal golden_visited.sort, visited.sort
+  end
+  
   def test_mutating_visit
     golden_visited = [
       [49, 'sub1', @sub1],