xcodeproj 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Eloy Durán <eloy.de.enige@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+# Xcodeproj
+
+Xcodeproj lets you create and modify Xcode projects from [MacRuby][macruby].
+Script boring management tasks or build Xcode-friendly libraries. Also includes
+support for Xcode workspaces (.xcworkspace) and configuration files (.xcconfig).
+
+It is used in [CocoaPods](https://github.com/cocoapods/cocoapods) to create a
+static library from scratch, for both iOS and OSX.
+
+
+## Installing Xcodeproj
+
+You’ll need MacRuby. xcodeproj itself installs through RubyGems, the Ruby
+package manager. Download and install [version 0.10][macruby-dl] and then
+perform the following command:
+
+    $ sudo macgem install xcodeproj
+
+The load time can be improved a bit by compiling the Ruby source files:
+
+    $ sudo macgem install rubygems-compile
+    $ sudo macgem compile xcodeproj
+
+
+## Colaborate
+
+All Xcodeproj development happens on [GitHub][xcodeproj]. Contributing patches
+is really easy and gratifying. You even get push access when one of your patches
+is accepted.
+
+Follow [@CocoaPodsOrg][twitter] to get up to date information about what's
+going on in the CocoaPods world.
+
+If you're really oldschool and you want to discuss Xcodeproj development you
+can join #cocoapods on irc.freenode.net.
+
+
+## Contributors
+
+* [Nolan Waite](https://github.com/nolanw)
+
+
+## LICENSE
+
+These works are available under the MIT license. See the [LICENSE][license] file
+for more info.
+
+Included in this package is the [inflector part of ActiveSupport][activesupport]
+which is also available under the MIT license.
+
+[twitter]: http://twitter.com/CocoaPodsOrg
+[macruby]: http://www.macruby.org
+[macruby-dl]: http://www.macruby.org/files
+[xcodeproj]: https://github.com/cocoapods/xcodeproj
+[tickets]: https://github.com/cocoapods/xcodeproj/issues
+[license]: xcodeproj/blob/master/LICENSE
+[activesupport]: https://github.com/rails/rails/tree/2-3-stable/activesupport

data/lib/xcodeproj.rb

@@ -0,0 +1,7 @@
+module Xcodeproj
+  VERSION = '0.0.1'
+  
+  autoload :Config,    'xcodeproj/config'
+  autoload :Project,   'xcodeproj/project'
+  autoload :Workspace, 'xcodeproj/workspace'
+end

data/lib/xcodeproj/config.rb

@@ -0,0 +1,31 @@
+module Xcodeproj
+  class Config
+    def initialize(xcconfig = {})
+      @attributes = {}
+      merge!(xcconfig)
+    end
+
+    def to_hash
+      @attributes
+    end
+
+    def merge!(xcconfig)
+      xcconfig.to_hash.each do |key, value|
+        if existing_value = @attributes[key]
+          @attributes[key] = "#{existing_value} #{value}"
+        else
+          @attributes[key] = value
+        end
+      end
+    end
+    alias_method :<<, :merge!
+
+    def to_s
+      @attributes.map { |key, value| "#{key} = #{value}" }.join("\n")
+    end
+
+    def save_as(pathname)
+      pathname.open('w') { |file| file << to_s }
+    end
+  end
+end

data/lib/xcodeproj/inflector.rb

@@ -0,0 +1,453 @@
+# encoding: utf-8
+
+# This is part of ActiveSupport, which is available under the MIT license>
+#
+# Copyright (c) 2005-2010 David Heinemeier Hansson
+#
+# From files:
+# * https://raw.github.com/rails/rails/2-3-stable/activesupport/lib/active_support/inflector.rb
+# * https://raw.github.com/rails/rails/2-3-stable/activesupport/lib/active_support/inflections.rb
+# * https://raw.github.com/rails/rails/2-3-stable/activesupport/lib/active_support/core_ext/string/inflections.rb
+
+require 'singleton'
+
+module Xcodeproj
+  module ActiveSupport
+    # The Inflector transforms words from singular to plural, class names to table names, modularized class names to ones without,
+    # and class names to foreign keys. The default inflections for pluralization, singularization, and uncountable words are kept
+    # in inflections.rb.
+    #
+    # The Rails core team has stated patches for the inflections library will not be accepted
+    # in order to avoid breaking legacy applications which may be relying on errant inflections.
+    # If you discover an incorrect inflection and require it for your application, you'll need
+    # to correct it yourself (explained below).
+    module Inflector
+      extend self
+
+      # A singleton instance of this class is yielded by Inflector.inflections, which can then be used to specify additional
+      # inflection rules. Examples:
+      #
+      #   ActiveSupport::Inflector.inflections do |inflect|
+      #     inflect.plural /^(ox)$/i, '\1\2en'
+      #     inflect.singular /^(ox)en/i, '\1'
+      #
+      #     inflect.irregular 'octopus', 'octopi'
+      #
+      #     inflect.uncountable "equipment"
+      #   end
+      #
+      # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
+      # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
+      # already have been loaded.
+      class Inflections
+        include Singleton
+
+        attr_reader :plurals, :singulars, :uncountables, :humans
+
+        def initialize
+          @plurals, @singulars, @uncountables, @humans = [], [], [], []
+        end
+
+        # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
+        # The replacement should always be a string that may include references to the matched data from the rule.
+        def plural(rule, replacement)
+          @uncountables.delete(rule) if rule.is_a?(String)
+          @uncountables.delete(replacement)
+          @plurals.insert(0, [rule, replacement])
+        end
+
+        # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
+        # The replacement should always be a string that may include references to the matched data from the rule.
+        def singular(rule, replacement)
+          @uncountables.delete(rule) if rule.is_a?(String)
+          @uncountables.delete(replacement)
+          @singulars.insert(0, [rule, replacement])
+        end
+
+        # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
+        # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
+        #
+        # Examples:
+        #   irregular 'octopus', 'octopi'
+        #   irregular 'person', 'people'
+        def irregular(singular, plural)
+          @uncountables.delete(singular)
+          @uncountables.delete(plural)
+          if singular[0,1].upcase == plural[0,1].upcase
+            plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
+            singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+          else
+            plural(Regexp.new("#{singular[0,1].upcase}(?i)#{singular[1..-1]}$"), plural[0,1].upcase + plural[1..-1])
+            plural(Regexp.new("#{singular[0,1].downcase}(?i)#{singular[1..-1]}$"), plural[0,1].downcase + plural[1..-1])
+            singular(Regexp.new("#{plural[0,1].upcase}(?i)#{plural[1..-1]}$"), singular[0,1].upcase + singular[1..-1])
+            singular(Regexp.new("#{plural[0,1].downcase}(?i)#{plural[1..-1]}$"), singular[0,1].downcase + singular[1..-1])
+          end
+        end
+
+        # Add uncountable words that shouldn't be attempted inflected.
+        #
+        # Examples:
+        #   uncountable "money"
+        #   uncountable "money", "information"
+        #   uncountable %w( money information rice )
+        def uncountable(*words)
+          (@uncountables << words).flatten!
+        end
+
+        # Specifies a humanized form of a string by a regular expression rule or by a string mapping.
+        # When using a regular expression based replacement, the normal humanize formatting is called after the replacement.
+        # When a string is used, the human form should be specified as desired (example: 'The name', not 'the_name')
+        #
+        # Examples:
+        #   human /_cnt$/i, '\1_count'
+        #   human "legacy_col_person_name", "Name"
+        def human(rule, replacement)
+          @humans.insert(0, [rule, replacement])
+        end
+
+        # Clears the loaded inflections within a given scope (default is <tt>:all</tt>).
+        # Give the scope as a symbol of the inflection type, the options are: <tt>:plurals</tt>,
+        # <tt>:singulars</tt>, <tt>:uncountables</tt>, <tt>:humans</tt>.
+        #
+        # Examples:
+        #   clear :all
+        #   clear :plurals
+        def clear(scope = :all)
+          case scope
+            when :all
+              @plurals, @singulars, @uncountables = [], [], []
+            else
+              instance_variable_set "@#{scope}", []
+          end
+        end
+      end
+
+      # Yields a singleton instance of Inflector::Inflections so you can specify additional
+      # inflector rules.
+      #
+      # Example:
+      #   ActiveSupport::Inflector.inflections do |inflect|
+      #     inflect.uncountable "rails"
+      #   end
+      def inflections
+        if block_given?
+          yield Inflections.instance
+        else
+          Inflections.instance
+        end
+      end
+
+      # Returns the plural form of the word in the string.
+      #
+      # Examples:
+      #   "post".pluralize             # => "posts"
+      #   "octopus".pluralize          # => "octopi"
+      #   "sheep".pluralize            # => "sheep"
+      #   "words".pluralize            # => "words"
+      #   "CamelOctopus".pluralize     # => "CamelOctopi"
+      def pluralize(word)
+        result = word.to_s.dup
+
+        if word.empty? || inflections.uncountables.include?(result.downcase)
+          result
+        else
+          inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+          result
+        end
+      end
+
+      # The reverse of +pluralize+, returns the singular form of a word in a string.
+      #
+      # Examples:
+      #   "posts".singularize            # => "post"
+      #   "octopi".singularize           # => "octopus"
+      #   "sheep".singluarize            # => "sheep"
+      #   "word".singularize             # => "word"
+      #   "CamelOctopi".singularize      # => "CamelOctopus"
+      def singularize(word)
+        result = word.to_s.dup
+
+        if inflections.uncountables.any? { |inflection| result =~ /#{inflection}\Z/i }
+          result
+        else
+          inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+          result
+        end
+      end
+
+      # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
+      # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
+      #
+      # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+      #
+      # Examples:
+      #   "active_record".camelize                # => "ActiveRecord"
+      #   "active_record".camelize(:lower)        # => "activeRecord"
+      #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
+      #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
+      def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+        if first_letter_in_uppercase
+          lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+        else
+          lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+        end
+      end
+
+      # Capitalizes all the words and replaces some characters in the string to create
+      # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
+      # used in the Rails internals.
+      #
+      # +titleize+ is also aliased as as +titlecase+.
+      #
+      # Examples:
+      #   "man from the boondocks".titleize # => "Man From The Boondocks"
+      #   "x-men: the last stand".titleize  # => "X Men: The Last Stand"
+      def titleize(word)
+        humanize(underscore(word)).gsub(/\b('?[a-z])/) { $1.capitalize }
+      end
+
+      # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
+      #
+      # Changes '::' to '/' to convert namespaces to paths.
+      #
+      # Examples:
+      #   "ActiveRecord".underscore         # => "active_record"
+      #   "ActiveRecord::Errors".underscore # => active_record/errors
+      def underscore(camel_cased_word)
+        camel_cased_word.to_s.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+      end
+
+      # Replaces underscores with dashes in the string.
+      #
+      # Example:
+      #   "puni_puni" # => "puni-puni"
+      def dasherize(underscored_word)
+        underscored_word.gsub(/_/, '-')
+      end
+
+      # Capitalizes the first word and turns underscores into spaces and strips a
+      # trailing "_id", if any. Like +titleize+, this is meant for creating pretty output.
+      #
+      # Examples:
+      #   "employee_salary" # => "Employee salary"
+      #   "author_id"       # => "Author"
+      def humanize(lower_case_and_underscored_word)
+        result = lower_case_and_underscored_word.to_s.dup
+
+        inflections.humans.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+        result.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+      end
+
+      # Removes the module part from the expression in the string.
+      #
+      # Examples:
+      #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
+      #   "Inflections".demodulize                                       # => "Inflections"
+      def demodulize(class_name_in_module)
+        class_name_in_module.to_s.gsub(/^.*::/, '')
+      end
+
+      # Create a class name from a plural table name like Rails does for table names to models.
+      # Note that this returns a string and not a Class. (To convert to an actual class
+      # follow +classify+ with +constantize+.)
+      #
+      # Examples:
+      #   "egg_and_hams".classify # => "EggAndHam"
+      #   "posts".classify        # => "Post"
+      #
+      # Singular names are not handled correctly:
+      #   "business".classify     # => "Busines"
+      def classify(table_name)
+        # strip out any leading schema name
+        camelize(singularize(table_name.to_s.sub(/.*\./, '')))
+      end
+
+      # Turns a number into an ordinal string used to denote the position in an
+      # ordered sequence such as 1st, 2nd, 3rd, 4th.
+      #
+      # Examples:
+      #   ordinalize(1)     # => "1st"
+      #   ordinalize(2)     # => "2nd"
+      #   ordinalize(1002)  # => "1002nd"
+      #   ordinalize(1003)  # => "1003rd"
+      def ordinalize(number)
+        if (11..13).include?(number.to_i % 100)
+          "#{number}th"
+        else
+          case number.to_i % 10
+            when 1; "#{number}st"
+            when 2; "#{number}nd"
+            when 3; "#{number}rd"
+            else    "#{number}th"
+          end
+        end
+      end
+    end
+
+    Inflector.inflections do |inflect|
+      inflect.plural(/$/, 's')
+      inflect.plural(/s$/i, 's')
+      inflect.plural(/(ax|test)is$/i, '\1es')
+      inflect.plural(/(octop|vir)us$/i, '\1i')
+      inflect.plural(/(alias|status)$/i, '\1es')
+      inflect.plural(/(bu)s$/i, '\1ses')
+      inflect.plural(/(buffal|tomat)o$/i, '\1oes')
+      inflect.plural(/([ti])um$/i, '\1a')
+      inflect.plural(/sis$/i, 'ses')
+      inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+      inflect.plural(/(hive)$/i, '\1s')
+      inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+      inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
+      inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
+      inflect.plural(/([m|l])ouse$/i, '\1ice')
+      inflect.plural(/^(ox)$/i, '\1en')
+      inflect.plural(/(quiz)$/i, '\1zes')
+
+      inflect.singular(/s$/i, '')
+      inflect.singular(/(n)ews$/i, '\1ews')
+      inflect.singular(/([ti])a$/i, '\1um')
+      inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
+      inflect.singular(/(^analy)ses$/i, '\1sis')
+      inflect.singular(/([^f])ves$/i, '\1fe')
+      inflect.singular(/(hive)s$/i, '\1')
+      inflect.singular(/(tive)s$/i, '\1')
+      inflect.singular(/([lr])ves$/i, '\1f')
+      inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
+      inflect.singular(/(s)eries$/i, '\1eries')
+      inflect.singular(/(m)ovies$/i, '\1ovie')
+      inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
+      inflect.singular(/([m|l])ice$/i, '\1ouse')
+      inflect.singular(/(bus)es$/i, '\1')
+      inflect.singular(/(o)es$/i, '\1')
+      inflect.singular(/(shoe)s$/i, '\1')
+      inflect.singular(/(cris|ax|test)es$/i, '\1is')
+      inflect.singular(/(octop|vir)i$/i, '\1us')
+      inflect.singular(/(alias|status)es$/i, '\1')
+      inflect.singular(/^(ox)en/i, '\1')
+      inflect.singular(/(vert|ind)ices$/i, '\1ex')
+      inflect.singular(/(matr)ices$/i, '\1ix')
+      inflect.singular(/(quiz)zes$/i, '\1')
+      inflect.singular(/(database)s$/i, '\1')
+
+      inflect.irregular('person', 'people')
+      inflect.irregular('man', 'men')
+      inflect.irregular('child', 'children')
+      inflect.irregular('sex', 'sexes')
+      inflect.irregular('move', 'moves')
+      inflect.irregular('cow', 'kine')
+
+      inflect.uncountable(%w(equipment information rice money species series fish sheep jeans))
+    end
+  end
+end
+
+# String inflections define new methods on the String class to transform names for different purposes.
+class NSString
+  include Xcodeproj::ActiveSupport
+
+  # Returns the plural form of the word in the string.
+  #
+  #   "post".pluralize             # => "posts"
+  #   "octopus".pluralize          # => "octopi"
+  #   "sheep".pluralize            # => "sheep"
+  #   "words".pluralize            # => "words"
+  #   "the blue mailman".pluralize # => "the blue mailmen"
+  #   "CamelOctopus".pluralize     # => "CamelOctopi"
+  def pluralize
+    Inflector.pluralize(self)
+  end
+
+  # The reverse of +pluralize+, returns the singular form of a word in a string.
+  #
+  #   "posts".singularize            # => "post"
+  #   "octopi".singularize           # => "octopus"
+  #   "sheep".singularize            # => "sheep"
+  #   "word".singularize             # => "word"
+  #   "the blue mailmen".singularize # => "the blue mailman"
+  #   "CamelOctopi".singularize      # => "CamelOctopus"
+  def singularize
+    Inflector.singularize(self)
+  end
+
+  # By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize
+  # is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
+  #
+  # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+  #
+  #   "active_record".camelize                # => "ActiveRecord"
+  #   "active_record".camelize(:lower)        # => "activeRecord"
+  #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
+  #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
+  def camelize(first_letter = :upper)
+    case first_letter
+      when :upper then Inflector.camelize(self, true)
+      when :lower then Inflector.camelize(self, false)
+    end
+  end
+  alias_method :camelcase, :camelize
+
+  # Capitalizes all the words and replaces some characters in the string to create
+  # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
+  # used in the Rails internals.
+  #
+  # +titleize+ is also aliased as +titlecase+.
+  #
+  #   "man from the boondocks".titleize # => "Man From The Boondocks"
+  #   "x-men: the last stand".titleize  # => "X Men: The Last Stand"
+  def titleize
+    Inflector.titleize(self)
+  end
+  alias_method :titlecase, :titleize
+
+  # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
+  # 
+  # +underscore+ will also change '::' to '/' to convert namespaces to paths.
+  #
+  #   "ActiveRecord".underscore         # => "active_record"
+  #   "ActiveRecord::Errors".underscore # => active_record/errors
+  def underscore
+    Inflector.underscore(self)
+  end
+
+  # Replaces underscores with dashes in the string.
+  #
+  #   "puni_puni" # => "puni-puni"
+  def dasherize
+    Inflector.dasherize(self)
+  end
+
+  # Removes the module part from the constant expression in the string.
+  #
+  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
+  #   "Inflections".demodulize                                       # => "Inflections"
+  def demodulize
+    Inflector.demodulize(self)
+  end
+
+  # Create a class name from a plural table name like Rails does for table names to models.
+  # Note that this returns a string and not a class. (To convert to an actual class
+  # follow +classify+ with +constantize+.)
+  #
+  #   "egg_and_hams".classify # => "EggAndHam"
+  #   "posts".classify        # => "Post"
+  #
+  # Singular names are not handled correctly.
+  #
+  #   "business".classify # => "Busines"
+  def classify
+    Inflector.classify(self)
+  end
+  
+  # Capitalizes the first word, turns underscores into spaces, and strips '_id'.
+  # Like +titleize+, this is meant for creating pretty output.
+  #
+  #   "employee_salary" # => "Employee salary" 
+  #   "author_id"       # => "Author"
+  def humanize
+    Inflector.humanize(self)
+  end
+end

data/lib/xcodeproj/project.rb

@@ -0,0 +1,664 @@
+framework 'Foundation'
+require 'fileutils'
+require 'xcodeproj/inflector'
+
+module Xcodeproj
+  class Project
+    class PBXObject
+      class AssociationReflection
+        def initialize(name, options)
+          @name, @options = name.to_s, options
+        end
+
+        attr_reader :name, :options
+
+        def klass
+          @options[:class] ||= begin
+            name = "PBX#{@name.classify}"
+            name = "XC#{@name.classify}" unless Project.const_defined?(name)
+            Project.const_get(name)
+          end
+        end
+
+        def inverse
+          klass.reflection(@options[:inverse_of])
+        end
+
+        def inverse?
+          !!@options[:inverse_of]
+        end
+
+        def singular_name
+          @options[:singular_name] || @name.singularize
+        end
+
+        def singular_getter
+          singular_name
+        end
+
+        def singular_setter
+          "#{singular_name}="
+        end
+
+        def plural_name
+          @name.pluralize
+        end
+
+        def plural_getter
+          plural_name
+        end
+
+        def plural_setter
+          "#{plural_name}="
+        end
+
+        def uuid_attribute
+          @options[:uuid] || @name
+        end
+
+        def uuid_method_name
+          (@options[:uuid] || @options[:uuids] || "#{singular_name}Reference").to_s.singularize
+        end
+
+        def uuid_getter
+          uuid_method_name
+        end
+
+        def uuid_setter
+          "#{uuid_method_name}="
+        end
+
+        def uuids_method_name
+          uuid_method_name.pluralize
+        end
+
+        def uuids_getter
+          uuids_method_name
+        end
+
+        def uuids_setter
+          "#{uuids_method_name}="
+        end
+      end
+
+      def self.reflections
+        @reflections ||= []
+      end
+
+      def self.create_reflection(name, options)
+        (reflections << AssociationReflection.new(name, options)).last
+      end
+
+      def self.reflection(name)
+        reflections.find { |r| r.name.to_s == name.to_s }
+      end
+
+      def self.attribute(attribute_name, accessor_name = nil)
+        attribute_name = attribute_name.to_s
+        name = (accessor_name || attribute_name).to_s
+        define_method(name) { @attributes[attribute_name] }
+        define_method("#{name}=") { |value| @attributes[attribute_name] = value }
+      end
+
+      def self.attributes(*names)
+        names.each { |name| attribute(name) }
+      end
+
+      def self.has_many(plural_attr_name, options = {}, &block)
+        reflection = create_reflection(plural_attr_name, options)
+        if reflection.inverse?
+          define_method(reflection.name) do
+            scoped = @project.objects.select_by_class(reflection.klass).select do |object|
+              object.send(reflection.inverse.uuid_getter) == self.uuid
+            end
+            PBXObjectList.new(reflection.klass, @project, scoped) do |object|
+              object.send(reflection.inverse.uuid_setter, self.uuid)
+            end
+          end
+        else
+          attribute(reflection.name, reflection.uuids_getter)
+          define_method(reflection.name) do
+            uuids = send(reflection.uuids_getter)
+            if block
+              # Evaluate the block, which was specified at the class level, in
+              # the instance’s context.
+              list_by_class(uuids, reflection.klass) do |object|
+                instance_exec(object, &block)
+              end
+            else
+              list_by_class(uuids, reflection.klass)
+            end
+          end
+          define_method(reflection.plural_setter) do |objects|
+            send(reflection.uuids_setter, objects.map(&:uuid))
+          end
+        end
+      end
+
+      def self.has_one(singular_attr_name, options = {})
+        reflection = create_reflection(singular_attr_name, options)
+        if reflection.inverse?
+          define_method(reflection.name) do
+            # Loop over all objects of the class and find the one that includes
+            # this object in the specified uuid list.
+            @project.objects.select_by_class(reflection.klass).find do |object|
+              object.send(reflection.inverse.uuids_getter).include?(self.uuid)
+            end
+          end
+          define_method(reflection.singular_setter) do |object|
+            # Remove this object from the uuid list of the target
+            # that this object was associated to.
+            if previous = send(reflection.name)
+              previous.send(reflection.inverse.uuids_getter).delete(self.uuid)
+            end
+            # Now assign this object to the new object
+            object.send(reflection.inverse.uuids_getter) << self.uuid if object
+          end
+        else
+          attribute(reflection.uuid_attribute, reflection.uuid_getter)
+          define_method(reflection.name) do
+            @project.objects[send(reflection.uuid_getter)]
+          end
+          define_method(reflection.singular_setter) do |object|
+            send(reflection.uuid_setter, object.uuid)
+          end
+        end
+      end
+
+      def self.isa
+        @isa ||= name.split('::').last
+      end
+
+      attr_reader :uuid, :attributes
+      attributes :isa, :name
+
+      def initialize(project, uuid, attributes)
+        @project, @attributes = project, attributes
+        unless uuid
+          # Add new objects to the main hash with a unique UUID
+          begin; uuid = generate_uuid; end while @project.objects_hash.has_key?(uuid)
+          @project.objects_hash[uuid] = @attributes
+        end
+        @uuid = uuid
+        self.isa ||= self.class.isa
+      end
+
+      def ==(other)
+        other.is_a?(PBXObject) && self.uuid == other.uuid
+      end
+
+      def inspect
+        "#<#{isa} UUID: `#{uuid}', name: `#{name}'>"
+      end
+
+      private
+
+      def generate_uuid
+        _uuid = CFUUIDCreate(nil)
+        uuid = CFUUIDCreateString(nil, _uuid)
+        CFRelease(_uuid)
+        CFMakeCollectable(uuid)
+        # Xcode's version is actually shorter, not worrying about collisions too much right now.
+        uuid.gsub('-', '')[0..23]
+      end
+
+      def list_by_class(uuids, klass, scoped = nil, &block)
+        unless scoped
+          scoped = uuids.map { |uuid| @project.objects[uuid] }.select { |o| o.is_a?(klass) }
+        end
+        if block
+          PBXObjectList.new(klass, @project, scoped, &block)
+        else
+          PBXObjectList.new(klass, @project, scoped) do |object|
+            # Add the uuid of a newly created object to the uuids list
+            uuids << object.uuid
+          end
+        end
+      end
+    end
+
+    # Missing constants that begin with either `PBX' or `XC' are assumed to be
+    # valid classes in a Xcode project. A new PBXObject subclass is created
+    # for the constant and returned.
+    def self.const_missing(name)
+      if name =~ /^(PBX|XC)/
+        klass = Class.new(PBXObject)
+        const_set(name, klass)
+        klass
+      else
+        super
+      end
+    end
+
+    class PBXFileReference < PBXObject
+      attributes :path, :sourceTree, :explicitFileType, :lastKnownFileType, :includeInIndex
+      has_many :buildFiles, :inverse_of => :file
+      has_one :group, :inverse_of => :children
+
+      def self.new_static_library(project, productName)
+        new(project, nil, {
+          "path"             => "lib#{productName}.a",
+          "includeInIndex"   => "0", # no idea what this is
+          "sourceTree"       => "BUILT_PRODUCTS_DIR",
+        })
+      end
+
+      def initialize(project, uuid, attributes)
+        is_new = uuid.nil?
+        super
+        self.path = path if path # sets default name
+        self.sourceTree ||= 'SOURCE_ROOT'
+        if is_new
+          @project.main_group.children << self
+        end
+        set_default_file_type!
+      end
+
+      alias_method :_path=, :path=
+      def path=(path)
+        self._path = path
+        self.name ||= pathname.basename.to_s
+        path
+      end
+
+      def pathname
+        Pathname.new(path)
+      end
+      
+      def set_default_file_type!
+        return if explicitFileType || lastKnownFileType
+        case path
+        when /\.a$/
+          self.explicitFileType = 'archive.ar'
+        when /\.framework$/
+          self.lastKnownFileType = 'wrapper.framework'
+        when /\.xcconfig$/
+          self.lastKnownFileType = 'text.xcconfig'
+        end
+      end
+    end
+
+    class PBXGroup < PBXObject
+      attributes :sourceTree
+
+      has_many :children, :class => PBXFileReference do |object|
+        if object.is_a?(Xcodeproj::Project::PBXFileReference)
+          # Associating the file to this group through the inverse
+          # association will also remove it from the group it was in.
+          object.group = self
+        else
+          # TODO What objects can actually be in a group and don't they
+          # all need the above treatment.
+          childReferences << object.uuid
+        end
+      end
+
+      def initialize(*)
+        super
+        self.sourceTree ||= '<group>'
+        self.childReferences ||= []
+      end
+
+      def files
+        list_by_class(childReferences, Xcodeproj::Project::PBXFileReference) do |file|
+          file.group = self
+        end
+      end
+
+      def source_files
+        files = self.files.reject { |file| file.buildFiles.empty? }
+        list_by_class(childReferences, Xcodeproj::Project::PBXFileReference, files) do |file|
+          file.group = self
+        end
+      end
+
+      def groups
+        list_by_class(childReferences, Xcodeproj::Project::PBXGroup)
+      end
+
+      def <<(child)
+        children << child
+      end
+    end
+
+    class PBXBuildFile < PBXObject
+      attributes :settings
+      has_one :file, :uuid => :fileRef
+    end
+
+    class PBXBuildPhase < PBXObject
+      # TODO rename this to buildFiles and add a files :through => :buildFiles shortcut
+      has_many :files, :class => PBXBuildFile
+
+      attributes :buildActionMask, :runOnlyForDeploymentPostprocessing
+
+      def initialize(*)
+        super
+        self.fileReferences ||= []
+        # These are always the same, no idea what they are.
+        self.buildActionMask ||= "2147483647"
+        self.runOnlyForDeploymentPostprocessing ||= "0"
+      end
+    end
+
+    class PBXCopyFilesBuildPhase < PBXBuildPhase
+      attributes :dstPath, :dstSubfolderSpec
+
+      def initialize(*)
+        super
+        self.dstSubfolderSpec ||= "16"
+      end
+    end
+
+    class PBXSourcesBuildPhase < PBXBuildPhase;     end
+    class PBXFrameworksBuildPhase < PBXBuildPhase;  end
+    class PBXShellScriptBuildPhase < PBXBuildPhase
+      attribute :shellScript
+    end
+
+    class PBXNativeTarget < PBXObject
+      STATIC_LIBRARY = 'com.apple.product-type.library.static'
+
+      attributes :productName, :productType
+
+      has_many :buildPhases
+      has_many :dependencies # TODO :class => ?
+      has_many :buildRules # TODO :class => ?
+      has_one :buildConfigurationList
+      has_one :product, :uuid => :productReference
+
+      def self.new_static_library(project, productName)
+        # TODO should probably switch the uuid and attributes argument
+        target = new(project, nil, 'productType' => STATIC_LIBRARY, 'productName' => productName)
+        target.product = project.files.new_static_library(productName)
+        products = project.groups.find { |g| g.name == 'Products' }
+        products ||= project.groups.new({ 'name' => 'Products'})
+        products.children << target.product
+        target.buildPhases.add(PBXSourcesBuildPhase)
+
+        buildPhase = target.buildPhases.add(PBXFrameworksBuildPhase)
+        frameworks = project.groups.find { |g| g.name == 'Frameworks' }
+        frameworks ||= project.groups.new({ 'name' => 'Frameworks'})
+        frameworks.files.each do |framework|
+          buildPhase.files << framework.buildFiles.new
+        end
+
+        target.buildPhases.add(PBXCopyFilesBuildPhase, 'dstPath' => '$(PUBLIC_HEADERS_FOLDER_PATH)')
+        target
+      end
+
+      # You need to specify a product. For a static library you can use
+      # PBXFileReference.new_static_library.
+      def initialize(project, *)
+        super
+        self.name ||= productName
+        self.buildRuleReferences  ||= []
+        self.dependencyReferences ||= []
+        self.buildPhaseReferences ||= []
+
+        unless buildConfigurationList
+          self.buildConfigurationList = project.objects.add(XCConfigurationList)
+          # TODO or should this happen in buildConfigurationList?
+          buildConfigurationList.buildConfigurations.new('name' => 'Debug')
+          buildConfigurationList.buildConfigurations.new('name' => 'Release')
+        end
+      end
+
+      alias_method :_product=, :product=
+      def product=(product)
+        self._product = product
+        product.group = @project.products
+      end
+
+      def buildConfigurations
+        buildConfigurationList.buildConfigurations
+      end
+
+      def source_build_phases
+        buildPhases.select_by_class(PBXSourcesBuildPhase)
+      end
+
+      def copy_files_build_phases
+        buildPhases.select_by_class(PBXCopyFilesBuildPhase)
+      end
+
+      def frameworks_build_phases
+        buildPhases.select_by_class(PBXFrameworksBuildPhase)
+      end
+
+      # Finds an existing file reference or creates a new one.
+      def add_source_file(path, copy_header_phase = nil, compiler_flags = nil)
+        file = @project.files.find { |file| file.path == path.to_s } || @project.files.new('path' => path.to_s)
+        buildFile = file.buildFiles.new
+        if path.extname == '.h'
+          buildFile.settings = { 'ATTRIBUTES' => ["Public"] }
+          # Working around a bug in Xcode 4.2 betas, remove this once the Xcode bug is fixed:
+          # https://github.com/alloy/cocoapods/issues/13
+          #phase = copy_header_phase || headers_build_phases.first
+          phase = copy_header_phase || copy_files_build_phases.first
+          phase.files << buildFile
+        else
+          buildFile.settings = { 'COMPILER_FLAGS' => compiler_flags } if compiler_flags
+          source_build_phases.first.files << buildFile
+        end
+        file
+      end
+    end
+
+    class XCBuildConfiguration < PBXObject
+      attribute :buildSettings
+      has_one :baseConfiguration, :uuid => :baseConfigurationReference
+
+      def initialize(*)
+        super
+        # TODO These are from an iOS static library, need to check if it works for any product type
+        self.buildSettings = {
+          'DSTROOT'                      => '/tmp/xcodeproj.dst',
+          'GCC_PRECOMPILE_PREFIX_HEADER' => 'YES',
+          'GCC_VERSION'                  => 'com.apple.compilers.llvm.clang.1_0',
+          'PRODUCT_NAME'                 => '$(TARGET_NAME)',
+          'SKIP_INSTALL'                 => 'YES',
+        }.merge(buildSettings || {})
+      end
+    end
+
+    class XCConfigurationList < PBXObject
+      has_many :buildConfigurations
+
+      def initialize(*)
+        super
+        self.buildConfigurationReferences ||= []
+      end
+    end
+
+    class PBXProject < PBXObject
+      has_many :targets, :class => PBXNativeTarget
+      has_one :products, :singular_name => :products, :uuid => :productRefGroup, :class => PBXGroup
+    end
+
+    class PBXObjectList
+      include Enumerable
+
+      def initialize(represented_class, project, scoped, &new_object_callback)
+        @represented_class = represented_class
+        @project           = project
+        @scoped_hash       = scoped.is_a?(Array) ? scoped.inject({}) { |h, o| h[o.uuid] = o.attributes; h } : scoped
+        @callback          = new_object_callback
+      end
+
+      def empty?
+        @scoped_hash.empty?
+      end
+
+      def [](uuid)
+        if hash = @scoped_hash[uuid]
+          Project.const_get(hash['isa']).new(@project, uuid, hash)
+        end
+      end
+
+      def add(klass, hash = {})
+        object = klass.new(@project, nil, hash)
+        @callback.call(object) if @callback
+        object
+      end
+
+      def new(hash = {})
+        add(@represented_class, hash)
+      end
+
+      def <<(object)
+        @callback.call(object) if @callback
+      end
+
+      def each
+        @scoped_hash.keys.each do |uuid|
+          yield self[uuid]
+        end
+      end
+
+      def ==(other)
+        self.to_a == other.to_a
+      end
+
+      def first
+        to_a.first
+      end
+
+      def last
+        to_a.last
+      end
+
+      def inspect
+        "<PBXObjectList: #{map(&:inspect)}>"
+      end
+
+      # Only makes sense on lists that contain mixed classes.
+      def select_by_class(klass)
+        scoped = @scoped_hash.select { |_, attr| attr['isa'] == klass.isa }
+        PBXObjectList.new(klass, @project, scoped) do |object|
+          # Objects added to the subselection should still use the same
+          # callback as this list.
+          self << object
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        if @represented_class.respond_to?(name)
+          object = @represented_class.send(name, @project, *args)
+          # The callbacks are only for PBXObject instances instantiated
+          # from the class method that we forwarded the message to.
+          @callback.call(object) if object.is_a?(PBXObject)
+          object
+        else
+          super
+        end
+      end
+    end
+
+    def initialize(xcodeproj = nil)
+      if xcodeproj
+        file = File.join(xcodeproj, 'project.pbxproj')
+        @plist = NSMutableDictionary.dictionaryWithContentsOfFile(file.to_s)
+      else
+        @plist = {
+          'archiveVersion' => '1',
+          'classes' => {},
+          'objectVersion' => '46',
+          'objects' => {}
+        }
+        self.root_object = objects.add(Xcodeproj::Project::PBXProject, {
+          'attributes' => { 'LastUpgradeCheck' => '0420' },
+          'compatibilityVersion' => 'Xcode 3.2',
+          'developmentRegion' => 'English',
+          'hasScannedForEncodings' => '0',
+          'knownRegions' => ['en'],
+          'mainGroup' => groups.new.uuid,
+          'projectDirPath' => '',
+          'projectRoot' => '',
+          'targets' => []
+        })
+      end
+    end
+
+    def to_hash
+      @plist
+    end
+
+    def objects_hash
+      @plist['objects']
+    end
+
+    def objects
+      @objects ||= PBXObjectList.new(PBXObject, self, objects_hash)
+    end
+
+    def root_object
+      objects[@plist['rootObject']]
+    end
+
+    def root_object=(object)
+      @plist['rootObject'] = object.uuid
+    end
+
+    def groups
+      objects.select_by_class(PBXGroup)
+    end
+    
+    def main_group
+      objects[root_object.attributes['mainGroup']]
+    end
+
+    def files
+      objects.select_by_class(PBXFileReference)
+    end
+
+    def add_system_framework(name)
+      files.new({
+        'name' => "#{name}.framework",
+        'path' => "System/Library/Frameworks/#{name}.framework",
+        'sourceTree' => 'SDKROOT'
+      })
+    end
+    
+    def add_shell_script_build_phase(name, script_path)
+      objects.add(Xcodeproj::Project::PBXShellScriptBuildPhase, {
+        'name' => name,
+        'files' => [],
+        'inputPaths' => [],
+        'outputPaths' => [],
+        'shellPath' => '/bin/sh',
+        'shellScript' => script_path
+      })
+    end
+
+    def build_files
+      objects.select_by_class(PBXBuildFile)
+    end
+
+    def targets
+      # Better to check the project object for targets to ensure they are
+      # actually there so the project will work
+      root_object.targets
+    end
+
+    def products
+      root_object.products
+    end
+
+    IGNORE_GROUPS = ['Frameworks', 'Products', 'Supporting Files']
+    def source_files
+      source_files = {}
+      groups.each do |group|
+        next if group.name.nil? || IGNORE_GROUPS.include?(group.name)
+        source_files[group.name] = group.source_files.map(&:pathname)
+      end
+      source_files
+    end
+
+    def save_as(projpath)
+      projpath = projpath.to_s
+      FileUtils.mkdir_p(projpath)
+      @plist.writeToFile(File.join(projpath, 'project.pbxproj'), atomically:true)
+    end
+  end
+end

data/lib/xcodeproj/workspace.rb

@@ -0,0 +1,54 @@
+framework 'Foundation'
+require 'fileutils'
+
+module Xcodeproj
+  class Workspace
+    def initialize(*projpaths)
+      @projpaths = projpaths
+    end
+    
+    def self.new_from_xcworkspace(path)
+      begin
+        from_s(File.read(File.join(path, 'contents.xcworkspacedata')))
+      rescue Errno::ENOENT
+        new
+      end
+    end
+    
+    def self.from_s(xml)
+      doc = NSXMLDocument.alloc.initWithXMLString(xml, options:0, error:nil)
+      projpaths = doc.nodesForXPath("/Workspace/FileRef", error:nil).map do |node|
+        node.attributeForName("location").stringValue.sub(/^group:/, '')
+      end
+      new(*projpaths)
+    end
+    
+    attr_reader :projpaths
+    
+    def <<(projpath)
+      @projpaths << projpath
+    end
+    
+    def include?(projpath)
+      @projpaths.include?(projpath)
+    end
+    
+    TEMPLATE = %q[<?xml version="1.0" encoding="UTF-8"?><Workspace version="1.0"></Workspace>]
+    def to_s
+      doc = NSXMLDocument.alloc.initWithXMLString(TEMPLATE, options:0, error:nil)
+      @projpaths.each do |projpath|
+        el = NSXMLNode.elementWithName("FileRef")
+        el.addAttribute(NSXMLNode.attributeWithName("location", stringValue:"group:#{projpath}"))
+        doc.rootElement.addChild(el)
+      end
+      NSString.alloc.initWithData(doc.XMLData, encoding:NSUTF8StringEncoding)
+    end
+    
+    def save_as(path)
+      FileUtils.mkdir_p(path)
+      File.open(File.join(path, 'contents.xcworkspacedata'), 'w') do |out|
+        out << to_s
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: xcodeproj
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Eloy Duran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-10 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Xcodeproj lets you create and modify Xcode projects from MacRuby. Script boring management tasks or build Xcode-friendly libraries. Also includes support for Xcode workspaces (.xcworkspace) and configuration files (.xcconfig).
+email: eloy.de.enige@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/xcodeproj/config.rb
+- lib/xcodeproj/inflector.rb
+- lib/xcodeproj/project.rb
+- lib/xcodeproj/workspace.rb
+- lib/xcodeproj.rb
+- README.md
+- LICENSE
+has_rdoc: true
+homepage: https://github.com/cocoapods/xcodeproj
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Create and modify Xcode projects from MacRuby.
+test_files: []
+