zerg_xcode 0.1

data/lib/zerg_xcode/objects/xcode_object.rb

@@ -0,0 +1,144 @@
+# Xcode objects
+class ZergXcode::XcodeObject
+  attr_accessor :version
+  attr_accessor :archive_id
+  
+  # Hash-like behavior
+  
+  def [](key)
+    @attrs[key]
+  end
+  
+  def []=(key, value)
+    @attrs[key] = value
+  end
+  
+  # Inheritance based on isa
+  
+  def initialize(hash)
+    @attrs = hash
+    if self.class != ZergXcode::XcodeObject
+      class_name = self.class.name
+      @attrs['isa'] ||= class_name[(class_name.rindex(':') + 1)..-1]
+    end
+  end
+  
+  def self.new(*args)
+    return super unless self == ZergXcode::XcodeObject
+    if hash_isa = args.first['isa']
+      classes = ZergXcode::Objects.constants
+      if classes.include? hash_isa
+        return ZergXcode::Objects.const_get(hash_isa).new(*args)
+      end
+    end
+    super
+  end  
+  
+  # Inspecting the object
+
+  # The names of the object's attributes. 
+  def attrs
+    @attrs.keys
+  end
+
+  # The (internal) hash holding the file's attributes.
+  def _attr_hash
+    @attrs
+  end
+  
+  # Object type helpers  
+  def isa
+    return @attrs['isa'].to_sym
+  end
+  
+  # Visitor pattern
+  
+  # Visits an object's internal structure.
+  #
+  # The given block is called like this:
+  #   yield object, parent, key, value
+  # Where
+  #   object: the object currently visited (can be a sub-object)
+  #   parent: the collection currently visited (an object, hash, or array)
+  #   key: 
+  #   value:
+  # The block can return
+  #   false: no recursive visiting for the given value
+  #   true: normal recursive visiting for the given value
+  #   something else: replace the given value with the return, the recursive
+  #                   visiting is done on the new value
+  def visit(&accept)
+    visit_hash(@attrs, &accept)
+    self
+  end
+
+  def visit_hash(hash, &accept)
+    hash.each_key do |key|
+      visit_value(hash, key, hash[key], &accept)
+    end
+    hash
+  end
+  
+  def visit_array(array, &accept)
+    array.each_with_index do |value, index|
+      visit_value(array, index, value, &accept)
+    end
+    array
+  end
+  
+  def visit_value(parent, key, value, &accept)
+    visit_parent = (parent == @attrs) ? self : parent
+    recurse = yield self, visit_parent, key, value
+    return if recurse == false
+    
+    if recurse != true
+      value = recurse
+      parent[key] = recurse
+    end
+    
+    case value
+    when ZergXcode::XcodeObject
+      value.visit(&accept)
+    when Hash
+      visit_hash(value, &accept)
+    when Array
+      visit_array(value, &accept)
+    end
+    value    
+  end
+    
+  # Deep copy
+  def self.from(object_or_hash)
+    new_object = case object_or_hash
+    when ZergXcode::XcodeObject
+      object_or_hash.shallow_copy
+    else
+      self.new object_or_hash.dup
+    end
+    object_map = { object_or_hash => new_object }
+    
+    new_object.visit do |object, parent, key, value|
+      case value
+      when Hash, Array
+        next value.dup
+      when ZergXcode::XcodeObject
+        if object_map[value]
+          parent[key] = object_map[value]
+          next false
+        else
+          object_map[value] = value.shallow_copy
+          next object_map[value]
+        end
+      else
+        next true
+      end
+    end
+  end
+  
+  def shallow_copy
+    new_object = self.class.new @attrs.dup
+    new_object.version, new_object.archive_id = version, archive_id
+    return new_object
+  end  
+end
+

data/lib/zerg_xcode/plugins/core/core.rb

@@ -0,0 +1,36 @@
+require 'set'
+
+module ZergXcode::Plugins
+  def self.all
+    plugin_dir = File.join(File.dirname(__FILE__), '..')
+    plugins = Dir.entries(plugin_dir).select { |entry|
+      /^[^_].*\.rb$/ =~ entry 
+    }.map { |entry| entry[0..-4] }
+    return Set.new(plugins)
+  end 
+  
+  def self.require_all
+    all.each { |plugin| self.require plugin }
+  end
+  
+  def self.require(plugin_name)
+    Kernel.require "zerg_xcode/plugins/#{plugin_name}.rb"
+  end
+  
+  def self.get(plugin_name)
+    self.require plugin_name
+    ZergXcode::Plugins.const_get(plugin_name.capitalize).new
+  end
+  
+  def self.run(plugin_name, args)
+    self.get(plugin_name).run args
+  end
+  
+  def self.help(plugin_name)
+    self.get(plugin_name).help
+  end
+end
+
+# :nodoc:
+module ZergXcode
+end

data/lib/zerg_xcode/plugins/help.rb

@@ -0,0 +1,30 @@
+class ZergXcode::Plugins::Help
+  def help
+    {:short => 'command-line usage instructions',
+     :long => <<"END" }
+Usage: help [command]
+
+Shows the usage for the given command. If no command is  given, shows a list of
+commands with a short description for each command.
+END
+  end
+  
+  def run(args)
+    helpstr = "Xcode Project Modifier brought to you by Zergling.Net.\n"
+  
+    plugin = args.shift
+    if ZergXcode::Plugins.all.include? plugin
+      help = ZergXcode::Plugins.get(plugin).help
+      helpstr << "#{plugin} - #{help[:short]}\n#{help[:long]}"
+    else
+      helpstr << "Available commands:\n"
+      ZergXcode::Plugins.all.each do |plugin|
+        short_help = ZergXcode::Plugins.get(plugin).help[:short]
+        helpstr << "  #{plugin}: #{short_help}\n"
+      end
+    end
+    
+    print helpstr
+    helpstr
+  end  
+end

data/lib/zerg_xcode/plugins/import.rb

@@ -0,0 +1,19 @@
+class ZergXcode::Plugins::Import
+  def help
+    {:short => 'imports the objects from a project into another project',
+     :long => <<"END" }
+Usage: import source_path [target_path]
+
+Imports the objects (build targets, files) from a source project into another
+target project. Useful when the source project wraps code that can be used as a
+library.
+END
+  end
+  
+  def run(args)
+    source = ZergXcode.load args.shift
+    target = ZergXcode.load(args.shift || '.')
+    
+    print "Import is not yet implemented."
+  end
+end

data/lib/zerg_xcode/plugins/irb.rb

@@ -0,0 +1,22 @@
+require 'irb'
+
+class ZergXcode::Plugins::Irb
+  def help
+    {:short => 'opens up a project in an interactive ruby shell',
+     :long => <<"END" }
+Usage: irb [path]
+
+Loads the object graph in the Xcode project at the given path. If no path is
+given, looks for a project in the current directory. The project object is
+available as the global variable $p.
+END
+  end
+  
+  def run(args)
+    $p = ZergXcode.load(args.shift || '.')
+    
+    print "This is an IRB shell. Your project is available as $p.\n" + 
+          "Use the 'quit' command if you're here by mistake.\n"
+    IRB.start __FILE__
+  end
+end

data/lib/zerg_xcode/plugins/ls.rb

@@ -0,0 +1,27 @@
+class ZergXcode::Plugins::Ls
+  def help
+    {:short => 'shows the files in a project',
+     :long => <<"END" }
+Usage: ls [path]
+
+Lists all the files in the project at the given path. If no path is given, looks
+for a project in the current directory.
+END
+  end
+  
+  def run(args)
+    list = list_for(args.shift || '.')
+    output = ""
+    list.each do |entry|
+      output << "%-20s %s\n" % [entry.last, entry.first]
+    end
+    print output
+    output
+  end
+  
+  def list_for(project_name)    
+    ZergXcode.load(project_name).all_files.map do |file|
+      [file[:path], file[:object]['lastKnownFileType']]
+    end
+  end  
+end

data/lib/zerg_xcode/plugins/retarget.rb

@@ -0,0 +1,90 @@
+class ZergXcode::Plugins::Retarget
+  include ZergXcode::Objects
+  XcodeObject = ZergXcode::XcodeObject
+  
+  def help
+    {:short => 'reassign files to a target or set of targets',
+     :long => <<"END" }
+Usage: retarget project_path pattern [target target..]
+
+Reassigns all the files matching a pattern to a target or set of targets. The
+files matching the pattern will be removed from all other targets. If no target
+is specified, the files are removed from all targets.
+END
+  end
+  
+  def run(args)
+    path = args.shift
+    pattern = args.shift
+    regexp = Regexp.compile pattern
+    project = ZergXcode.load path
+    retarget! project, regexp, args
+    project.save!
+  end
+  
+  def retarget!(project, regexp, targets)
+    # maps each file type to the type of the phase it's in
+    file_type_phases = {}
+    # maps each file to the phase it's in
+    file_phases = {}
+    # maps each PBXFileRef to the PBXBuildFile pointing to it
+    build_files = {}
+    
+    # populate the maps
+    project['targets'].each do |target|
+      target.all_files.each do |file|
+        build_file = file[:build_object]
+        phase_type = file[:phase]['isa']
+        build_files[file[:object]] = build_file
+        file_type_phases[build_file.file_type] = phase_type
+        file_phases[file[:object]] = phase_type
+      end
+    end
+    
+    # compute target sets
+    in_targets = project['targets'].select do |target|
+      targets.include? target['name']
+    end
+    out_targets = project['targets'] - in_targets
+    
+    # clean up targets outside the args
+    out_targets.each do |target|
+      target['buildPhases'].each do |phase|
+        phase['files'].reject! { |build_file| regexp =~ build_file.filename }
+      end
+    end
+
+    # build a list of the files in the project matching the pattern
+    new_files = project.all_files.map { |file| file[:object] }.select do |file|
+      regexp =~ file['path']
+    end
+    # build PBXBuildFile wrappers around files that don't have them
+    new_files.each do |file|
+      next if build_files[file]
+      
+      build_file = PBXBuildFile.new 'fileRef' => file
+      build_files[file] = build_file
+      file_phases[file] = file_type_phases[build_file.file_type] ||
+          build_file.guessed_build_phase_type
+    end
+    
+    # add files to targets matching the args
+    in_targets.each do |target|
+      already_in = Set.new(target.all_files.map { |file| file[:object] })      
+      new_files.each do |file|
+        file_ref = file[:object]
+        next if already_in.include? file
+        phase_type = file_phases[file]
+        phase = target['buildPhases'].find { |p| p['isa'] ==  phase_type }
+        unless phase
+          phase = XcodeObject.new 'isa' => phase_type, 'dependencies' => [],
+                                  'files' => [],
+                                  'buildActionMask' => '2147483647',
+                                  'runOnlyForDeploymentPostprocessing' => '0'
+          target['buildPhases'] << phase
+        end
+        phase['files'] << build_files[file]
+      end
+    end
+  end
+end

data/lib/zerg_xcode/shortcuts.rb

@@ -0,0 +1,22 @@
+module ZergXcode
+  # Reads an Xcode project from the filesystem.
+  def self.load(path)
+    file = ZergXcode::Paths.project_file_at path
+    pbx_contents = File.read file
+    project = Archiver.unarchive pbx_contents
+    project.source_filename = file
+    return project
+  end
+  
+  # Dumps an Xcode project to the filesystem.
+  def self.dump(project, path)
+    file = ZergXcode::Paths.project_file_at path
+    pbx_contents = Archiver.archive project
+    File.open(file, 'w') { |f| f.write pbx_contents }
+  end
+  
+  # Instantiate a plug-in.
+  def self.plugin(plugin_name)
+    ZergXcode::Plugins.get(plugin_name)
+  end  
+end

data/lib/zerg_xcode.rb

@@ -0,0 +1,17 @@
+module ZergXcode; end
+module ZergXcode::Objects; end
+
+
+require 'zerg_xcode/file_format/archiver.rb'
+require 'zerg_xcode/file_format/encoder.rb'
+require 'zerg_xcode/file_format/lexer.rb'
+require 'zerg_xcode/file_format/parser.rb'
+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_native_target.rb'
+require 'zerg_xcode/objects/pbx_project.rb'
+require 'zerg_xcode/plugins/core/core.rb'
+
+require 'zerg_xcode/shortcuts.rb'

data/test/file_format/archiver_test.rb

@@ -0,0 +1,70 @@
+require 'test/unit'
+require 'zerg_xcode'
+
+class ArchiverTest < Test::Unit::TestCase
+  Parser = ZergXcode::Parser
+  Archiver = ZergXcode::Archiver
+  XcodeObject = ZergXcode::XcodeObject
+  
+  def setup
+    @sub1 = XcodeObject.new :array => ['a', 'b', 'c'], :string => 's'
+    @sub1.archive_id = '39'
+    @sub2 = XcodeObject.new :hash => { :k => 'v', :k2 => 'v2' }, :sub1 => @sub1
+    @sub2.archive_id = '42'
+    @root = XcodeObject.new :sub1 => @sub1, :sub2 => @sub2
+    @root.archive_id = '49'
+    @root.version = 45
+    
+    @archived = {
+      "archiveVersion" => '1',
+      "rootObject" => '49',
+      "classes" => {},
+      "objectVersion" => '45',
+      "objects" => {
+        "49" => { :sub1 => "39", :sub2 => "42" },
+        "39" => { :array => ["a", "b", "c"], :string => "s" },
+        "42" => { :hash => { :k => "v", :k2 => "v2" }, :sub1 => "39" }
+      }
+    }
+    
+    @pbxdata = File.read 'testdata/project.pbxproj'     
+  end
+  
+  def test_archive_to_hash    
+    hash = Archiver.archive_to_hash @root
+    assert_equal @archived, hash
+  end
+  
+  def test_unarchive_hash
+    root = Archiver.unarchive_hash @archived
+    assert_equal @sub1[:s], root[:sub1][:s]
+    assert_equal @sub1[:array], root[:sub1][:array]
+    assert_equal @sub2[:hash], root[:sub2][:hash]
+    assert_equal root[:sub1], root[:sub2][:sub1], 'Object graph split'
+  end
+
+  def test_generator
+   generator = Archiver::IdGenerator.new
+   assert_equal '49', generator.id_for(@root)
+   assert_equal '42', generator.id_for(@sub2)
+   new_id = generator.id_for @root
+   assert '49' != new_id, 'Initial ID generated twice'
+   newer_id = generator.id_for @root
+   assert !['49', new_id].include?(newer_id), 'New ID generated twice'
+ end
+ 
+ def test_archive_passthrough
+   golden_hash = Parser.parse @pbxdata
+   project = Archiver.unarchive @pbxdata
+   dupdata = Archiver.archive project
+   
+   assert_equal golden_hash, Parser.parse(dupdata) 
+ end
+ 
+ def test_unarchive
+   project = Archiver.unarchive @pbxdata
+   
+   assert_equal 'TestApp.app',
+                project['targets'][0]['productReference']['path']
+ end
+end

data/test/file_format/encoder_test.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+
+class EncoderTest < Test::Unit::TestCase
+  def test_encoder
+    pbxdata = File.read 'testdata/project.pbxproj'
+    golden_encoded_proj = File.read 'testdata/project.pbxproj.compat'
+    proj = ZergXcode::Parser.parse pbxdata
+    assert_equal golden_encoded_proj, ZergXcode::Encoder.encode(proj)
+  end  
+end

data/test/file_format/lexer_test.rb

@@ -0,0 +1,56 @@
+require 'test/unit'
+require 'zerg_xcode'
+
+class LexerTest < Test::Unit::TestCase
+  def test_lexer
+    pbxdata = File.read 'testdata/project.pbxproj'
+    golden_starts = [[:encoding, "UTF8"],
+                     :begin_hash,
+                       [:symbol, "archiveVersion"], :assign, [:symbol, "1"],
+                       :stop,
+                       [:symbol, "classes"], :assign, :begin_hash, :end_hash,
+                       :stop,
+                       [:symbol, "objectVersion"], :assign, [:symbol, "45"],
+                       :stop,
+                       [:symbol, "objects"], :assign, :begin_hash,
+                         [:symbol, "1D3623260D0F684500981E51"], :assign,
+                         :begin_hash,
+                           [:symbol, "isa"], :assign, [:symbol, "PBXBuildFile"],
+                           :stop,
+                           [:symbol, "fileRef"], :assign,
+                             [:symbol, "1D3623250D0F684500981E51"],
+                           :stop,
+                         :end_hash,
+                         :stop,
+                         [:symbol, "1D60589B0D05DD56006BFB54"], :assign,
+                         :begin_hash,
+                           [:symbol, "isa"], :assign, [:symbol, "PBXBuildFile"],
+                           :stop,
+                           [:symbol, "fileRef"], :assign,
+                             [:symbol, "29B97316FDCFA39411CA2CEA"],
+                           :stop,
+                         :end_hash,
+                         :stop,
+                         [:symbol, "1D60589F0D05DD5A006BFB54"], :assign,
+                         :begin_hash,
+                           [:symbol, "isa"], :assign, [:symbol, "PBXBuildFile"],
+                           :stop,
+                           [:symbol, "fileRef"], :assign,
+                             [:symbol, "1D30AB110D05D00D00671497"],
+                           :stop,
+                         :end_hash,
+                         :stop]
+    
+    tokens = ZergXcode::Lexer.tokenize pbxdata
+    assert_equal golden_starts, tokens[0, golden_starts.length]
+    #p tokens.length
+    #p tokens[197, 50]
+  end
+  
+  def test_escaped_string
+    pbxdata = File.read 'testdata/ZergSupport.xcodeproj/project.pbxproj'
+    tokens = ZergXcode::Lexer.tokenize pbxdata
+    assert tokens.include?([:string,
+                            "\"$(SRCROOT)/build/Debug-iphonesimulator\""])
+  end
+end

data/test/file_format/parser_test.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+
+class ParserTest < Test::Unit::TestCase
+  def test_parser
+    pbxdata = File.read 'testdata/project.pbxproj'
+    proj = ZergXcode::Parser.parse pbxdata
+    
+    assert proj.kind_of?(Hash), 'Project structure should be a hash'
+    assert_equal '1', proj['archiveVersion'], 'Archive version'
+    assert_equal '45', proj['objectVersion'], 'Object version'
+    assert_equal '29B97313FDCFA39411CA2CEA', proj['rootObject'], 'Root object'
+    
+    golden_file_ref = {
+      'isa' => 'PBXBuildFile',
+      'fileRef' => '28AD733E0D9D9553002E5188'
+    }
+    assert_equal golden_file_ref, proj['objects']['28AD733F0D9D9553002E5188']
+    
+    golden_file = {
+      'isa' => 'PBXFileReference',
+      'fileEncoding' => '4',
+      'lastKnownFileType' => 'sourcecode.c.h',
+      'path' => 'TestAppViewController.h',
+      'sourceTree' => "<group>"
+    }
+    assert_equal golden_file, proj['objects']['28D7ACF60DDB3853001CB0EB']
+    
+    golden_config = {
+      'isa' => 'XCBuildConfiguration',
+      'buildSettings' => {
+        'ARCHS' => "$(ARCHS_STANDARD_32_BIT)",
+        "CODE_SIGN_IDENTITY[sdk=iphoneos*]" => "iPhone Developer",
+        'GCC_C_LANGUAGE_STANDARD' => 'c99',
+        'GCC_WARN_ABOUT_RETURN_TYPE' => 'YES',
+        'GCC_WARN_UNUSED_VARIABLE' => 'YES',
+        'ONLY_ACTIVE_ARCH' => 'YES',
+        'PREBINDING' => 'NO',
+        'SDKROOT' => 'iphoneos2.2.1'
+      },
+      'name' => 'Debug'
+    }
+    assert_equal golden_config, proj['objects']['C01FCF4F08A954540054247B']
+  end
+end

data/test/file_format/path_test.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+
+class PathTest < Test::Unit::TestCase
+  Paths = ZergXcode::Paths
+  
+  def test_project_file_at
+    assert_equal 'testdata/ZergSupport.xcodeproj/project.pbxproj',
+                 Paths.project_file_at('testdata/ZergSupport'), 'short'
+    assert_equal 'testdata/ZergSupport.xcodeproj/project.pbxproj',
+                 Paths.project_file_at('testdata/ZergSupport.xcodeproj'),
+                 'full project name'
+    assert_equal 'testdata/project.pbxproj',
+                 Paths.project_file_at('testdata'),
+                 'enclosing dir with weird name'
+    assert_equal './testdata/project.pbxproj',
+                 Paths.project_file_at('.'),
+                 'subdir with weird name'
+    assert_equal 'testdata/TestApp/TestApp.xcodeproj/project.pbxproj',
+                 Paths.project_file_at('testdata/TestApp'), 'project in subdir'
+    assert_equal 'testdata/TestApp/TestApp.xcodeproj/project.pbxproj',
+                 Paths.project_file_at('testdata/TestApp/TestApp.xcodeproj'),
+                 'full project name in subdir'
+  end
+  
+  def test_project_root_at
+    assert_equal 'testdata', Paths.project_root_at('testdata/ZergSupport'),
+                 'short project name'
+    assert_equal 'testdata',
+                 Paths.project_root_at('testdata/ZergSupport.xcodeproj'),
+                 'full project name'
+    assert_equal '.', Paths.project_root_at('testdata'),
+                 'enclosing dir with weird name'
+    assert_equal '.', Paths.project_root_at('.'), 'subdir with weird name'    
+    assert_equal 'testdata/TestApp',
+                 Paths.project_root_at('testdata/TestApp'), 'project dir'
+    assert_equal 'testdata/TestApp',
+                 Paths.project_root_at('testdata/TestApp/TestApp.xcodeproj'),
+                 'full project name in subdir'
+  end
+end

data/test/objects/pbx_build_file_test.rb

@@ -0,0 +1,38 @@
+require 'test/unit'
+
+require 'zerg_xcode'
+
+class PBXBuildFileTest < Test::Unit::TestCase
+  PBXBuildFile = ZergXcode::Objects::PBXBuildFile
+  
+  def setup
+    @target = ZergXcode.load('testdata/project.pbxproj')['targets'].first
+  end
+  
+  def test_attributes
+    sources_phase = @target['buildPhases'][1]
+    build_file = sources_phase['files'].first
+    assert_equal PBXBuildFile, build_file.class
+    assert_equal 'main.m', build_file.filename
+    assert_equal 'sourcecode.c.objc', build_file.file_type
+    
+    big_project = ZergXcode.load('testdata/ZergSupport')
+    big_project['targets'].map { |t| t.all_files }.flatten.each do |file|
+      assert_not_nil file[:build_object].file_type,
+                     "No file type for #{file[:build_object].inspect}"
+    end
+  end
+  
+  def test_guessed_build_phase_type
+    big_project = ZergXcode.load('testdata/ZergSupport')
+        
+    phases = @target['buildPhases'] +
+        big_project['targets'].map { |t| t['buildPhases'] }.flatten
+    phases.each do |phase|
+      phase['files'].each do |file|
+        assert_equal phase['isa'], file.guessed_build_phase_type,
+                     "Wrong phase for #{file.inspect}"
+      end
+    end
+  end
+end