xcodeproj 0.1.0 → 0.2.0

data/README.md

@@ -1,6 +1,7 @@
 # Xcodeproj
 
-[![Build Status](https://secure.travis-ci.org/CocoaPods/Xcodeproj.png)](https://secure.travis-ci.org/CocoaPods/Xcodeproj)
+[![Master Build Status](https://secure.travis-ci.org/CocoaPods/Xcodeproj.png?branch=master)](https://secure.travis-ci.org/CocoaPods/Xcodeproj)
+[![Develop Build Status](https://secure.travis-ci.org/CocoaPods/Xcodeproj.png?branch=develop)](https://secure.travis-ci.org/CocoaPods/Xcodeproj)
 
 Xcodeproj lets you create and modify Xcode projects from [Ruby][ruby].
 Script boring management tasks or build Xcode-friendly libraries. Also includes
@@ -15,7 +16,7 @@ static library from scratch, for both iOS and OSX.
 Xcodeproj itself installs through RubyGems, the Ruby package manager. Install it
 by performing the following command:
 
-    $ sudo gem install xcodeproj
+    $ [sudo] gem install xcodeproj --pre
 
 
 ## Colaborate
@@ -31,13 +32,6 @@ If you're really oldschool and you want to discuss Xcodeproj development you
 can join #cocoapods on irc.freenode.net.
 
 
-## Authors
-
-* [Nolan Waite](https://github.com/nolanw)
-* [Luke Redpath](https://github.com/lukeredpath)
-* [Eloy Durán](https://github.com/alloy)
-
-
 ## LICENSE
 
 These works are available under the MIT license. See the [LICENSE][license] file

data/ext/xcodeproj/extconf.rb

@@ -37,6 +37,7 @@ end
 have_header 'CoreFoundation/CoreFoundation.h'
 have_header 'CoreFoundation/CFStream.h'
 have_header 'CoreFoundation/CFPropertyList.h'
+have_header 'ruby/st.h'
 
 create_header
 create_makefile 'xcodeproj_ext'

data/ext/xcodeproj/xcodeproj_ext.c

@@ -4,7 +4,10 @@
 #include "extconf.h"
 
 #include "ruby.h"
+#if HAVE_RUBY_ST_H
 #include "ruby/st.h"
+#endif
+
 #include "CoreFoundation/CoreFoundation.h"
 #include "CoreFoundation/CFStream.h"
 #include "CoreFoundation/CFPropertyList.h"
@@ -14,12 +17,22 @@ VALUE Xcodeproj = Qnil;
 
 static VALUE
 cfstr_to_str(const void *cfstr) {
-  long len = (long)CFStringGetLength(cfstr);
+  CFDataRef data = CFStringCreateExternalRepresentation(NULL, cfstr, kCFStringEncodingUTF8, 0);
+  assert(data != NULL);
+  long len = (long)CFDataGetLength(data);
   char *buf = (char *)malloc(len+1);
   assert(buf != NULL);
-  CFStringGetCString(cfstr, buf, len+1, kCFStringEncodingUTF8);
+  CFDataGetBytes(data, CFRangeMake(0, len), buf);
+
   register VALUE str = rb_str_new(buf, len);
   free(buf);
+
+  // force UTF-8 encoding in Ruby 1.9+
+  ID forceEncodingId = rb_intern("force_encoding");
+  if (rb_respond_to(str, forceEncodingId)) {
+    rb_funcall(str, forceEncodingId, 1, rb_str_new("UTF-8", 5));
+  }
+
   return str;
 }
 
@@ -29,7 +42,14 @@ str_to_cfstr(VALUE str) {
   return CFStringCreateWithCString(NULL, RSTRING_PTR(rb_String(str)), kCFStringEncodingUTF8);
 }
 
-
+/* Generates a UUID. The original version is truncated, so this is not 100%
+ * guaranteed to be unique. However, the `PBXObject#generate_uuid` method
+ * checks that the UUID does not exist yet, in the project, before using it.
+ *
+ * @note Meant for internal use only.
+ *
+ * @return [String] A 24 characters long UUID.
+ */
 static VALUE
 generate_uuid(void) {
   CFUUIDRef uuid = CFUUIDCreate(NULL);
@@ -69,11 +89,22 @@ hash_set(const void *keyRef, const void *valueRef, void *hash) {
     value = rb_ary_new();
     CFIndex i, count = CFArrayGetCount(valueRef);
     for (i = 0; i < count; i++) {
-      CFStringRef x = CFArrayGetValueAtIndex(valueRef, i);
-      if (CFGetTypeID(x) == CFStringGetTypeID()) {
-        rb_ary_push(value, cfstr_to_str(x));
+      CFTypeRef elementRef = CFArrayGetValueAtIndex(valueRef, i);
+      CFTypeID elementType = CFGetTypeID(elementRef);
+      if (elementType == CFStringGetTypeID()) {
+        rb_ary_push(value, cfstr_to_str(elementRef));
+
+      } else if (elementType == CFDictionaryGetTypeID()) {
+        VALUE hashElement = rb_hash_new();
+        CFDictionaryApplyFunction(elementRef, hash_set, (void *)hashElement);
+        rb_ary_push(value, hashElement);
+
       } else {
-        rb_raise(rb_eTypeError, "Plist array value contains a object type unsupported by Xcodeproj.");
+        CFStringRef descriptionRef = CFCopyDescription(elementRef);
+        // obviously not optimial, but we're raising here, so it doesn't really matter
+        VALUE description = cfstr_to_str(descriptionRef);
+        rb_raise(rb_eTypeError, "Plist array value contains a object type unsupported by Xcodeproj. In: `%s'", RSTRING_PTR(description));
+        CFRelease(descriptionRef);
       }
     }
 
@@ -94,15 +125,26 @@ dictionary_set(st_data_t key, st_data_t value, CFMutableDictionaryRef dict) {
                                          0,
                                          &kCFTypeDictionaryKeyCallBacks,
                                          &kCFTypeDictionaryValueCallBacks);
-    st_foreach(RHASH_TBL(value), dictionary_set, (st_data_t)valueRef);
+    rb_hash_foreach(value, dictionary_set, (st_data_t)valueRef);
 
   } else if (TYPE(value) == T_ARRAY) {
     long i, count = RARRAY_LEN(value);
     valueRef = CFArrayCreateMutable(NULL, count, &kCFTypeArrayCallBacks);
     for (i = 0; i < count; i++) {
-      CFStringRef x = str_to_cfstr(RARRAY_PTR(value)[i]);
-      CFArrayAppendValue((CFMutableArrayRef)valueRef, x);
-      CFRelease(x);
+      VALUE element = RARRAY_PTR(value)[i];
+      CFTypeRef elementRef = NULL;
+      if (TYPE(element) == T_HASH) {
+        elementRef = CFDictionaryCreateMutable(NULL,
+                                               0,
+                                               &kCFTypeDictionaryKeyCallBacks,
+                                               &kCFTypeDictionaryValueCallBacks);
+        rb_hash_foreach(element, dictionary_set, (st_data_t)elementRef);
+      } else {
+        // otherwise coerce to string
+        elementRef = str_to_cfstr(element);
+      }
+      CFArrayAppendValue((CFMutableArrayRef)valueRef, elementRef);
+      CFRelease(elementRef);
     }
 
   } else {
@@ -130,7 +172,19 @@ str_to_url(VALUE path) {
 }
 
 
-// TODO handle errors
+/* @overload read_plist(path)
+ *
+ * Reads from the specified path and de-serializes the property list.
+ *
+ * @note This does not yet support all possible types that can exist in a valid property list.
+ *
+ * @note This currently only assumes to be given an Xcode project document.
+ *       This means that it only accepts dictionaries, arrays, and strings in
+ *       the document.
+ *
+ * @param [String] path  The path to the property list file.
+ * @return [Hash]        The dictionary contents of the document.
+ */
 static VALUE
 read_plist(VALUE self, VALUE path) {
   CFPropertyListRef dict;
@@ -159,6 +213,20 @@ read_plist(VALUE self, VALUE path) {
   return hash;
 }
 
+/* @overload write_plist(hash, path)
+ *
+ * Writes the serialized contents of a property list to the specified path.
+ *
+ * @note This does not yet support all possible types that can exist in a valid property list.
+ *
+ * @note This currently only assumes to be given an Xcode project document.
+ *       This means that it only accepts dictionaries, arrays, and strings in
+ *       the document.
+ *
+ * @param [Hash] hash     The property list to serialize.
+ * @param [String] path   The path to the property list file.
+ * @return [true, false]  Wether or not saving was successful.
+ */
 static VALUE
 write_plist(VALUE self, VALUE hash, VALUE path) {
   VALUE h = rb_check_convert_type(hash, T_HASH, "Hash", "to_hash");
@@ -171,7 +239,7 @@ write_plist(VALUE self, VALUE hash, VALUE path) {
                                                           &kCFTypeDictionaryKeyCallBacks,
                                                           &kCFTypeDictionaryValueCallBacks);
 
-  st_foreach(RHASH_TBL(h), dictionary_set, (st_data_t)dict);
+  rb_hash_foreach(h, dictionary_set, (st_data_t)dict);
 
   CFURLRef fileURL = str_to_url(path);
   CFWriteStreamRef stream = CFWriteStreamCreateWithFile(NULL, fileURL);

data/lib/xcodeproj/config.rb

@@ -1,31 +1,163 @@
 module Xcodeproj
+  # This class holds the data for a Xcode build settings file (xcconfig) and
+  # serializes it.
   class Config
-    def initialize(xcconfig = {})
+    # Returns a new instance of Config
+    #
+    # @param [Hash, File, String] xcconfig_hash_or_file  Initial data.
+    require 'set'
+
+    attr_accessor :attributes, :frameworks ,:libraries
+
+    def initialize(xcconfig_hash_or_file = {})
       @attributes = {}
-      merge!(xcconfig)
+      @includes = []
+      @frameworks, @libraries = Set.new, Set.new
+      merge!(extract_hash(xcconfig_hash_or_file))
     end
 
+    # @return [Hash] The internal data.
     def to_hash
-      @attributes
+      hash = @attributes.dup
+      flags = hash['OTHER_LDFLAGS'] || ''
+      flags = flags.dup.strip
+      flags << libraries.to_a.sort.reduce('')  {| memo, l | memo << " -l#{l}" }
+      flags << frameworks.to_a.sort.reduce('') {| memo, f | memo << " -framework #{f}" }
+      hash['OTHER_LDFLAGS'] = flags.strip
+      hash.delete('OTHER_LDFLAGS') if flags.strip.empty?
+      hash
     end
 
+    def ==(other)
+      other.respond_to?(:to_hash) && other.to_hash == self.to_hash
+    end
+
+    # @return [Array] Config's include file list
+    # @example
+    #
+    # Consider following xcconfig file:
+    #
+    #   #include "SomeConfig"
+    #   Key1 = Value1
+    #   Key2 = Value2
+    #
+    #   config.includes # => [ "SomeConfig" ]
+    def includes
+      @includes
+    end
+
+    # Merges the given xcconfig hash or Config into the internal data.
+    #
+    # If a key in the given hash already exists, in the internal data, then its
+    # value is appended to the value in the internal data.
+    #
+    # @example
+    #
+    #   config = Config.new('PODS_ROOT' => '"$(SRCROOT)/Pods"', 'OTHER_LDFLAGS' => '-lxml2')
+    #   config.merge!('OTHER_LDFLAGS' => '-lz', 'HEADER_SEARCH_PATHS' => '"$(PODS_ROOT)/Headers"')
+    #   config.to_hash # => { 'PODS_ROOT' => '"$(SRCROOT)/Pods"', 'OTHER_LDFLAGS' => '-lxml2 -lz', 'HEADER_SEARCH_PATHS' => '"$(PODS_ROOT)/Headers"' }
+    #
+    # @param [Hash, Config] xcconfig  The data to merge into the internal data.
     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
+      if xcconfig.is_a? Config
+        @attributes.merge!(xcconfig.attributes) { |key, v1, v2| "#{v1} #{v2}" }
+        @libraries.merge   xcconfig.libraries
+        @frameworks.merge  xcconfig.frameworks
+      else
+      @attributes.merge!(xcconfig.to_hash) { |key, v1, v2| "#{v1} #{v2}" }
+      # Parse frameworks and libraries. Then remove the from the linker flags
+      flags = @attributes['OTHER_LDFLAGS']
+      return unless flags
+
+      frameworks = flags.scan(/-framework\s+([^\s]+)/).map { |m| m[0] }
+      libraries  = flags.scan(/-l ?([^\s]+)/).map { |m| m[0] }
+      @frameworks.merge frameworks
+      @libraries.merge libraries
+
+      new_flags = flags.dup
+      frameworks.each {|f| new_flags.gsub!("-framework #{f}", "") }
+      libraries.each  {|l| new_flags.gsub!("-l#{l}", ""); new_flags.gsub!("-l #{l}", "") }
+      @attributes['OTHER_LDFLAGS'] = new_flags.gsub("\w*", ' ').strip
       end
     end
     alias_method :<<, :merge!
 
+    def merge(config)
+      self.dup.tap { |x|x.merge!(config) }
+    end
+
+    def dup
+      Xcodeproj::Config.new(self.to_hash.dup)
+    end
+
+    # Serializes the internal data in the xcconfig format.
+    #
+    # @example
+    #
+    #   config = Config.new('PODS_ROOT' => '"$(SRCROOT)/Pods"', 'OTHER_LDFLAGS' => '-lxml2')
+    #   config.to_s # => "PODS_ROOT = \"$(SRCROOT)/Pods\"\nOTHER_LDFLAGS = -lxml2"
+    #
+    # @return [String]  The serialized internal data.
     def to_s
-      @attributes.map { |key, value| "#{key} = #{value}" }.join("\n")
+      to_hash.map { |key, value| "#{key} = #{value}" }.join("\n")
+    end
+
+    def inspect
+      to_hash.inspect
     end
 
+    # Writes the serialized representation of the internal data to the given
+    # path.
+    #
+    # @param [Pathname] pathname  The file that the data should be written to.
     def save_as(pathname)
       pathname.open('w') { |file| file << to_s }
     end
+
+    private
+
+    def extract_hash(argument)
+      if argument.respond_to? :read
+        hash_from_file_content(argument.read)
+      elsif File.readable? argument.to_s
+        hash_from_file_content(File.read(argument))
+      else
+        argument
+      end
+    end
+
+    def hash_from_file_content(raw_string)
+      hash = {}
+      raw_string.split("\n").each do |line|
+        uncommented_line = strip_comment(line)
+        if include = extract_include(uncommented_line)
+          @includes.push include
+        else
+          key, value = extract_key_value(uncommented_line)
+          hash[key] = value if key
+        end
+      end
+      hash
+    end
+
+    def strip_comment(line)
+      line.partition('//').first
+    end
+
+    def extract_include(line)
+      regexp = /#include\s*"(.+)"/
+      match = line.match(regexp)
+      match[1] if match
+    end
+
+    def extract_key_value(line)
+      key, value = line.split('=', 2)
+      if key && value
+        [key.strip, value.strip]
+      else
+        []
+      end
+    end
+
   end
 end

data/lib/xcodeproj/inflector.rb

@@ -189,7 +189,7 @@ module Xcodeproj
         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]
+          lower_case_and_underscored_word[0,1].downcase + camelize(lower_case_and_underscored_word)[1..-1]
         end
       end
 

data/lib/xcodeproj/project/association/has_many.rb

@@ -0,0 +1,51 @@
+module Xcodeproj
+  class Project
+    module Object
+      class Association
+
+        class HasMany < Association
+          def direct_get
+            uuids = @owner.send(@reflection.attribute_getter)
+            if @block
+              # Evaluate the block, which was specified at the class level, in
+              # the instance’s context.
+              @owner.list_by_class(uuids, @reflection.klass) do |list|
+                list.let(:push) do |new_object|
+                  @owner.instance_exec(new_object, &@block)
+                end
+              end
+            else
+              @owner.list_by_class(uuids, @reflection.klass)
+            end
+          end
+
+          def inverse_get
+            PBXObjectList.new(@reflection.klass, @owner.project) do |list|
+              list.let(:uuid_scope) do
+                @owner.project.objects.list_by_class(@reflection.klass).select do |object|
+                  object.send(@reflection.inverse.attribute_getter) == @owner.uuid
+                end.map(&:uuid)
+              end
+              list.let(:push) do |new_object|
+                new_object.send(@reflection.inverse.attribute_setter, @owner.uuid)
+              end
+            end
+          end
+
+          # @todo Currently this does not call the @block, which means that
+          #       in theory (like with a group's children) the object stays
+          #       asociated with its old group.
+          def direct_set(list)
+            @owner.send(@reflection.attribute_setter, list.map(&:uuid))
+          end
+
+          def inverse_set(list)
+            raise NotImplementedError
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/lib/xcodeproj/project/association/has_one.rb

@@ -0,0 +1,39 @@
+module Xcodeproj
+  class Project
+    module Object
+      class Association
+
+        # @todo Does this need 'new object'-callback support too?
+        class HasOne < Association
+          def direct_get
+            @owner.project.objects[@owner.send(@reflection.attribute_getter)]
+          end
+
+          def inverse_get
+            # Loop over all objects of the class and find the one that includes
+            # this object in the specified uuid list.
+            @owner.project.objects.list_by_class(@reflection.klass).find do |object|
+              object.send(@reflection.inverse.attribute_getter).include?(@owner.uuid)
+            end
+          end
+
+          def direct_set(object)
+            @owner.send(@reflection.attribute_setter, object.uuid)
+          end
+
+          def inverse_set(object)
+            # Remove this object from the uuid list of the target
+            # that this object was associated to.
+            if previous = @owner.send(@reflection.name)
+              previous.send(@reflection.inverse.attribute_getter).delete(@owner.uuid)
+            end
+            # Now assign this object to the new object
+            object.send(@reflection.inverse.attribute_getter) << @owner.uuid if object
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/lib/xcodeproj/project/association/reflection.rb

@@ -0,0 +1,88 @@
+require 'xcodeproj/inflector'
+
+module Xcodeproj
+  class Project
+    module Object
+
+      class AbstractPBXObject
+        def self.reflections
+          @reflections ||= []
+        end
+
+        def self.create_reflection(type, name, options)
+          (reflections << Association::Reflection.new(type, name, options)).last
+        end
+
+        def self.reflection(name)
+          reflections.find { |r| r.name.to_s == name.to_s }
+        end
+      end
+
+      class Association
+        class Reflection
+          def initialize(type, name, options)
+            @type, @name, @options = type, name.to_s, options
+          end
+
+          attr_reader :type, :name, :options
+
+          def klass
+            @options[:class] ||= begin
+              name = "PBX#{@name.classify}"
+              name = "XC#{@name.classify}" unless Xcodeproj::Project::Object.const_defined?(name)
+              Xcodeproj::Project::Object.const_get(name)
+            end
+          end
+
+          def inverse
+            klass.reflection(@options[:inverse_of])
+          end
+
+          def inverse?
+            !!@options[:inverse_of]
+          end
+
+          def attribute_name
+            (@options[:uuid] || @options[:uuids] || @name).to_sym
+          end
+
+          def attribute_getter
+            case type
+            when :has_many
+              uuid_method_name.pluralize
+            when :has_one
+              uuid_method_name
+            end.to_sym
+          end
+
+          def attribute_setter
+            "#{attribute_getter}=".to_sym
+          end
+
+          def getter
+            @name.to_sym
+          end
+
+          def setter
+            "#{@name}=".to_sym
+          end
+
+          def association_for(owner, &block)
+            case type
+            when :has_many then Association::HasMany
+            when :has_one  then Association::HasOne
+            end.new(owner, self, &block)
+          end
+
+          private
+
+          def uuid_method_name
+            (@options[:uuids_as] || @options[:uuid] || @options[:uuids] || "#{@name.singularize}_reference").to_s.singularize
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/xcodeproj/project/association.rb

@@ -0,0 +1,54 @@
+require 'xcodeproj/project/association/has_many'
+require 'xcodeproj/project/association/has_one'
+require 'xcodeproj/project/association/reflection'
+
+module Xcodeproj
+  class Project
+    module Object
+
+      class AbstractPBXObject
+        class << self
+          def has_many(plural_attr_name, options = {}, &block)
+            create_association(:has_many, plural_attr_name, options, &block)
+          end
+
+          def has_one(singular_attr_name, options = {})
+            create_association(:has_one, singular_attr_name, options)
+          end
+
+          private
+
+          def create_association(type, name, options, &block)
+            reflection = create_reflection(type, name, options)
+            unless reflection.inverse?
+              attribute(reflection.attribute_name, :as => reflection.attribute_getter)
+            end
+            define_method(reflection.getter) do
+              reflection.association_for(self, &block).get
+            end
+            define_method(reflection.setter) do |new_value|
+              reflection.association_for(self, &block).set(new_value)
+            end
+          end
+        end
+      end
+
+      class Association
+        attr_reader :owner, :reflection
+
+        def initialize(owner, reflection, &block)
+          @owner, @reflection, @block = owner, reflection, block
+        end
+
+        def get
+          @reflection.inverse? ? inverse_get : direct_get
+        end
+
+        def set(value)
+          @reflection.inverse? ? inverse_set(value) : direct_set(value)
+        end
+      end
+
+    end
+  end
+end