xcodeproj 0.19.2 → 0.19.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1129b473d86da3499713744a267d7d8f5ffd9efb
-  data.tar.gz: ab2240c06b99dc3cccdfc3efaa471425b06d6ee6
+  metadata.gz: b11e16ee772fb9a6ff3bbd07499cb06885df731b
+  data.tar.gz: c735f33b3e62c3401d7ef35dd916dcae3275a540
 SHA512:
-  metadata.gz: ca89358ff49c9a8688a25ab5bcfef6c43903879b68f3757fef972a60a8d16b2fa96c025dee010323abb0c90053466d3f2dad066c3b43f4cfa823f3af9bc6bad6
-  data.tar.gz: 563f05cce3f9828c5e9869f585ebd775d5c43ad3492735a3544bf5bd05ea6201aea3c3007cb75c431bccef265186ace283b9bd167f3eb135586dc5cfe4bdf073
+  metadata.gz: ba65247e5b10b9cd78af4a7f455b267aae9baef88d71aec7eccc502f56be2cb4b2ae26dc4acdb643acd2bab68d2791b8fb54617fe85f2ee7cda483077b1fe311
+  data.tar.gz: 9473e5e8c751dab5aedf06638c111394e6fe71ec2e855199637e31aee1b57b61986126eae88eb0c972e7f7bce15568156d842a513c9ef9f33f402e21f5c53966

data/README.md

@@ -20,10 +20,6 @@ by performing the following command:
 
     $ [sudo] gem install xcodeproj
 
-To improve the performance of Xcodeproj it is possible to install [LibXML Ruby](http://xml4r.github.io/libxml-ruby/):
-
-    $ [sudo] gem install libxml-ruby
-    
 To make Xcodeproj output projects in the same format of Xcode (deprecated ASCII Plists format) in order to reduce the SCM noise it is possible to install [xcproj](https://github.com/0xced/xcproj):
 
     $ brew install xcproj

data/lib/xcodeproj.rb

@@ -20,13 +20,6 @@ module Xcodeproj
   autoload :Workspace,        'xcodeproj/workspace'
   autoload :XCScheme,         'xcodeproj/scheme'
   autoload :XcodebuildHelper, 'xcodeproj/xcodebuild_helper'
-
-  # TODO: Delete me (compatibility with CocoaPods 0.33.1)
-  def self.read_plist(path)
-    PlistHelper.read(path)
-  end
-
-  def self.write_plist(hash, path)
-    PlistHelper.write(hash, path)
-  end
 end
+
+require 'xcodeproj/ext'

data/lib/xcodeproj/config.rb

@@ -31,7 +31,7 @@ module Xcodeproj
       @attributes = {}
       @includes = []
       @other_linker_flags = {}
-      [:simple, :frameworks, :weak_frameworks, :libraries].each do |key|
+      [:simple, :frameworks, :weak_frameworks, :libraries, :force_load].each do |key|
         @other_linker_flags[key] = Set.new
       end
       merge!(extract_hash(xcconfig_hash_or_file))
@@ -94,11 +94,16 @@ module Xcodeproj
         :frameworks => '-framework ',
         :weak_frameworks => '-weak_framework ',
         :libraries => '-l',
+        :force_load => '-force_load',
       }
-      [:libraries, :frameworks, :weak_frameworks].each do |key|
+      [:libraries, :frameworks, :weak_frameworks, :force_load].each do |key|
         modifier = modifiers[key]
         sorted = other_linker_flags[key].to_a.sort
-        list += sorted.map { |l| %(#{modifier}"#{l}") }
+        if key == :force_load
+          list += sorted.map { |l| %(#{modifier} #{l}) }
+        else
+          list += sorted.map { |l| %(#{modifier}"#{l}") }
+        end
       end
 
       result = attributes.dup

data/lib/xcodeproj/config/other_linker_flags_parser.rb

@@ -17,6 +17,7 @@ module Xcodeproj
           :weak_frameworks => [],
           :libraries => [],
           :simple => [],
+          :force_load => [],
         }
 
         key = nil
@@ -28,6 +29,8 @@ module Xcodeproj
             key = :weak_frameworks
           when '-l'
             key = :libraries
+          when '-force_load'
+            key = :force_load
           else
             if key
               result[key] << token

data/lib/xcodeproj/ext.rb

@@ -1 +1,12 @@
-# TODO: Delete me
+begin
+  require 'xcodeproj/plist_helper'
+rescue LoadError
+  require 'rbconfig'
+  if RUBY_VERSION == '1.8.7' && RbConfig::CONFIG['prefix'] =~ %r{^/System/Library/Frameworks/Ruby.framework/}
+    $:.unshift(File.expand_path('../../../ext', __FILE__))
+    require 'xcodeproj/xcodeproj_ext'
+  else
+    raise 'The xcodeproj gem is only supported on Ruby versions that include' \
+          'the Fiddle API or with Ruby 1.8.7 that came with OS X 10.8.x.'
+  end
+end

data/lib/xcodeproj/gem_version.rb

@@ -1,5 +1,5 @@
 module Xcodeproj
   # The version of the xcodeproj gem.
   #
-  VERSION = '0.19.2' unless defined? Xcodeproj::VERSION
+  VERSION = '0.19.3' unless defined? Xcodeproj::VERSION
 end

data/lib/xcodeproj/plist_helper.rb

@@ -1,15 +1,19 @@
-require 'cfpropertylist'
-require 'open3'
+require 'fiddle'
 
 module Xcodeproj
+  # TODO: Delete me (compatibility with Ruby 1.8.7 C ext bundle)
+  def self.read_plist(path)
+    PlistHelper.read(path)
+  end
+
+  # TODO: Delete me (compatibility with Ruby 1.8.7 C ext bundle)
+  def self.write_plist(hash, path)
+    PlistHelper.write(hash, path)
+  end
+
   # Provides support for loading and serializing property list files.
   #
-  # @note CFPropertyList will automatically pick up the `libxml` strategy or
-  #       other faster strategies, if their dependencies are available.
-  #
   module PlistHelper
-    PLUTIL_BIN = '/usr/bin/plutil'
-
     class << self
       # Serializes a hash as an XML property list file.
       #
@@ -24,100 +28,404 @@ module Xcodeproj
           if hash.respond_to?(:to_hash)
             hash = hash.to_hash
           else
-            raise TypeError, "The given `#{hash}`, must be a hash or " \
-              'respond to to_hash'
+            raise TypeError, "The given `#{hash.inspect}` must be a hash or " \
+                             "respond to #to_hash'."
           end
         end
 
         unless path.is_a?(String) || path.is_a?(Pathname)
-          raise TypeError, "The given `#{path}`, must be a string or " \
-            'pathname'
-        end
-        plist = CFPropertyList::List.new
-        options = { :convert_unknown_to_string => true }
-        plist.value = CFPropertyList.guess(hash, options)
-
-        if plutil_available?
-          contents = plist.to_str(CFPropertyList::List::FORMAT_XML)
-          plutil_save(contents, path)
-        else
-          plist.save(path, CFPropertyList::List::FORMAT_XML)
+          raise TypeError, "The given `#{path}` must be a string or 'pathname'."
         end
+        path = path.to_s
+
+        CoreFoundation.RubyHashPropertyListWrite(hash, path)
       end
 
-      # @return [String] Returns the native objects loaded from a property list
+      # @return [Hash] Returns the native objects loaded from a property list
       #         file.
       #
       # @param  [#to_s] path
       #         The path of the file.
       #
       def read(path)
+        path = path.to_s
         unless File.exist?(path)
-          raise ArgumentError, "The file `#{path}` doesn't exists"
+          raise ArgumentError, "The plist file at path `#{path}` doesn't exist."
         end
-        xml = plist_xml_contents(path)
-        plist = CFPropertyList::List.new
-        plist.load_xml_str(xml)
-        CFPropertyList.native_types(plist.value)
+        CoreFoundation.RubyHashPropertyListRead(path)
       end
+    end
+  end
+end
 
-      private
+# This module provides an interface to the CoreFoundation OS X framework.
+# Specifically it bridges the functions required to be able to read and write
+# property lists.
+#
+# Everything in here should be considered an implementation detail and thus is
+# not further documented.
+#
+# @todo Move this out into its own gem.
+#
+module CoreFoundation
+  PATH = '/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation'
 
-      # @!group Private Helpers
-      #-----------------------------------------------------------------------#
+  # rubocop:disable Style/MethodName
+  # rubocop:disable Style/VariableName
 
-      # @return [String] Returns the contents of a property list file with
-      #         Converting it to XML using the `plutil` tool if needed and
-      #         available.
-      #
-      # @param  [#to_s] path
-      #         The path of the file.
-      #
-      def plist_xml_contents(path)
-        contents = File.read(path)
-        if contents.include?('?xml')
-          contents
-        elsif plutil_available?
-          plutil_contents(path)
-        else
-          raise "Unable to convert the `#{path}` plist file to XML"
-        end
-      end
+  # @!group Ruby hash as property list (de)serialization
+  #---------------------------------------------------------------------------#
 
-      # @return [String] The contents of plist file normalized to XML via
-      #         `plutil` tool.
-      #
-      # @param  [#to_s] path
-      #         The path of the file.
-      #
-      # @note   This method was extracted to simplify testing.
-      #
-      def plutil_contents(path)
-        `#{PLUTIL_BIN} -convert xml1 "#{path}" -o -`
-      end
+  def self.RubyHashPropertyListWrite(hash, path)
+    url = CFURLCreateFromFileSystemRepresentation(NULL,
+                                                  path,
+                                                  path.bytesize,
+                                                  FALSE)
+    stream = CFWriteStreamCreateWithFile(NULL, url)
+    unless CFWriteStreamOpen(stream) == TRUE
+      raise IOError, 'Unable to open stream.'
+    end
 
-      # Saves a property to an XML file via the plutil tool.
-      #
-      # @param  [#to_s] contents.
-      #         The contents of the property list.
-      #
-      # @param  [#to_s] path
-      #         The path of the file.
-      #
-      def plutil_save(contents, path)
-        Open3.popen3("#{PLUTIL_BIN} -convert xml1 -o '#{path}' -") do |stdin, stdout, _stderr|
-          stdin.puts(contents)
-          stdin.close
-          stdout.read # Make Ruby 1.8.7 wait
-        end
+    plist = RubyHashToCFDictionary(hash)
+
+    error_ptr = CFTypeRefPointer()
+    result = CFPropertyListWrite(plist,
+                                 stream,
+                                 KCFPropertyListXMLFormat_v1_0,
+                                 0,
+                                 error_ptr)
+    CFWriteStreamClose(stream)
+
+    if result == 0
+      description = CFCopyDescription(error_ptr.ptr)
+      raise IOError, "Unable to write plist data: #{description}"
+    end
+    result
+  end
+
+  def self.RubyHashPropertyListRead(path)
+    url = CFURLCreateFromFileSystemRepresentation(NULL,
+                                                  path,
+                                                  path.bytesize,
+                                                  FALSE)
+    stream = CFReadStreamCreateWithFile(NULL, url)
+    unless CFReadStreamOpen(stream) == TRUE
+      raise IOError, 'Unable to open stream.'
+    end
+
+    error_ptr = CFTypeRefPointer()
+    plist = CFPropertyListCreateWithStream(NULL,
+                                           stream,
+                                           0,
+                                           KCFPropertyListImmutable,
+                                           NULL,
+                                           error_ptr)
+    CFReadStreamClose(stream)
+
+    if plist.null?
+      description = CFCopyDescription(error_ptr.ptr)
+      raise IOError, "Unable to read plist data: #{description}"
+    elsif CFGetTypeID(plist) != CFDictionaryGetTypeID()
+      raise TypeError, 'Expected a plist with a dictionary root object.'
+    end
+
+    CFDictionaryToRubyHash(plist)
+  end
+
+  # @!group Types
+  #---------------------------------------------------------------------------#
+
+  # rubocop:disable Style/ConstantName
+
+  NULL = Fiddle::NULL
+
+  Void = Fiddle::TYPE_VOID
+  VoidPointer = Fiddle::TYPE_VOIDP
+  FunctionPointer = VoidPointer
+
+  UInt32 = -Fiddle::TYPE_INT
+  UInt8 = -Fiddle::TYPE_CHAR
+
+  SInt32Pointer = VoidPointer
+  UInt8Pointer = VoidPointer
+  CharPointer = VoidPointer
+
+  Boolean = Fiddle::TYPE_CHAR
+  TRUE = 1
+  FALSE = 0
+
+  CFTypeRef = VoidPointer
+  CFTypeRefPointer = VoidPointer
+  CFIndex = Fiddle::TYPE_LONG
+  CFTypeID = -Fiddle::TYPE_LONG
+  CFOptionFlags = UInt32
+
+  CFPropertyListMutabilityOptions = Fiddle::TYPE_INT
+  KCFPropertyListImmutable = 0
+
+  CFPropertyListFormat = Fiddle::TYPE_INT
+  KCFPropertyListXMLFormat_v1_0 = 100
+  CFPropertyListFormatPointer = VoidPointer
+
+  CFStringEncoding = UInt32
+  KCFStringEncodingUTF8 = 0x08000100
+
+  # rubocop:enable Style/ConstantName
+
+  private
+
+  # @!group Helpers
+  #---------------------------------------------------------------------------#
+
+  def self.image
+    @image ||= Fiddle.dlopen(PATH)
+  end
+
+  def self.free_function
+    @ruby_free ||= Fiddle::Function.new(Fiddle::RUBY_FREE, [VoidPointer], Void)
+  end
+
+  def self.CFRelease_function
+    @CFRelease ||= Fiddle::Function.new(image['CFRelease'], [CFTypeRef], Void)
+  end
+
+  def self.extern(symbol, parameter_types, return_type)
+    symbol = symbol.to_s
+    create_function = symbol.include?('Create')
+    function_cache_key = "@__#{symbol}__"
+
+    # Define a singleton method on the CoreFoundation module.
+    define_singleton_method(symbol) do |*args|
+      unless args.size == parameter_types.size
+        raise ArgumentError, "wrong number of arguments (#{args.size} for " \
+                             "#{parameter_types.size})"
       end
 
-      # @return [Bool] Whether the `plutil` tool is available.
-      #
-      def plutil_available?
-        @plutil_available = File.executable?(PLUTIL_BIN) if @plutil_available.nil?
-        @plutil_available
+      unless function = instance_variable_get(function_cache_key)
+        function = Fiddle::Function.new(image[symbol],
+                                        parameter_types,
+                                        return_type)
+        instance_variable_set(function_cache_key, function)
       end
+
+      result = function.call(*args)
+      create_function ? CFAutoRelease(result) : result
     end
   end
+
+  public
+
+  # @!group CoreFoundation function definitions
+  #---------------------------------------------------------------------------#
+
+  # CFTypeRef description
+  extern :CFShow, [CFTypeRef], Void
+  extern :CFCopyDescription, [CFTypeRef], CFTypeRef
+
+  # CFType reflection
+  extern :CFGetTypeID, [CFTypeRef], CFTypeID
+  extern :CFDictionaryGetTypeID, [], CFTypeID
+  extern :CFStringGetTypeID, [], CFTypeID
+  extern :CFArrayGetTypeID, [], CFTypeID
+  extern :CFBooleanGetTypeID, [], CFTypeID
+
+  # CFStream
+  extern :CFWriteStreamCreateWithFile, [CFTypeRef, CFTypeRef], CFTypeRef
+  extern :CFWriteStreamOpen, [CFTypeRef], Boolean
+  extern :CFWriteStreamClose, [CFTypeRef], Void
+  extern :CFReadStreamCreateWithFile, [CFTypeRef, CFTypeRef], CFTypeRef
+  extern :CFReadStreamOpen, [CFTypeRef], Boolean
+  extern :CFReadStreamClose, [CFTypeRef], Void
+
+  # CFURL
+  extern :CFURLCreateFromFileSystemRepresentation, [CFTypeRef, UInt8Pointer, CFIndex, Boolean], CFTypeRef
+
+  # CFPropertyList
+  extern :CFPropertyListWrite, [CFTypeRef, CFTypeRef, CFPropertyListFormat, CFOptionFlags, CFTypeRefPointer], CFIndex
+  extern :CFPropertyListCreateWithStream, [CFTypeRef, CFTypeRef, CFIndex, CFOptionFlags, CFPropertyListFormatPointer, CFTypeRefPointer], CFTypeRef
+
+  # CFString
+  extern :CFStringCreateExternalRepresentation, [CFTypeRef, CFTypeRef, CFStringEncoding, UInt8], CFTypeRef
+  extern :CFStringCreateWithCString, [CFTypeRef, CharPointer, CFStringEncoding], CFTypeRef
+
+  # CFData
+  extern :CFDataGetLength, [CFTypeRef], CFIndex
+  extern :CFDataGetBytePtr, [CFTypeRef], VoidPointer
+
+  # CFDictionary
+  extern :CFDictionaryCreateMutable, [CFTypeRef, CFIndex, VoidPointer, VoidPointer], CFTypeRef
+  extern :CFDictionaryAddValue, [CFTypeRef, CFTypeRef, CFTypeRef], VoidPointer
+  extern :CFDictionaryApplyFunction, [CFTypeRef, FunctionPointer, VoidPointer], Void
+
+  # CFArray
+  extern :CFArrayCreateMutable, [CFTypeRef, CFIndex, VoidPointer], CFTypeRef
+  extern :CFArrayAppendValue, [CFTypeRef, CFTypeRef], VoidPointer
+  extern :CFArrayGetCount, [CFTypeRef], CFIndex
+  extern :CFArrayGetValueAtIndex, [CFTypeRef, CFIndex], CFTypeRef
+
+  # CFBoolean
+  extern :CFBooleanGetValue, [CFTypeRef], Boolean
+
+  # @!group Custom convenience functions
+  #---------------------------------------------------------------------------#
+
+  def self.CFBooleanTrue
+    @CFBooleanTrue ||= Fiddle::Pointer.new(image['kCFBooleanTrue']).ptr
+  end
+
+  def self.CFBooleanFalse
+    @CFBooleanFalse ||= Fiddle::Pointer.new(image['kCFBooleanFalse']).ptr
+  end
+
+  def self.CFTypeArrayCallBacks
+    @CFTypeArrayCallBacks ||= image['kCFTypeArrayCallBacks']
+  end
+
+  def self.CFTypeDictionaryKeyCallBacks
+    @CFTypeDictionaryKeyCallBacks ||= image['kCFTypeDictionaryKeyCallBacks']
+  end
+
+  def self.CFTypeDictionaryValueCallBacks
+    @CFTypeDictionaryValueCallBacks ||= image['kCFTypeDictionaryValueCallBacks']
+  end
+
+  # This pointer will assign `CFRelease` as the free function when
+  # dereferencing the pointer.
+  #
+  def self.CFTypeRefPointer
+    pointer = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INTPTR_T, free_function)
+    def pointer.ptr
+      CFAutoRelease(super)
+    end
+    pointer
+  end
+
+  def self.CFAutoRelease(cf_type_reference)
+    cf_type_reference.free = CFRelease_function() unless cf_type_reference.null?
+    cf_type_reference
+  end
+
+  def self.CFDictionaryApplyBlock(dictionary, &applier)
+    param_types = [CFTypeRef, CFTypeRef, VoidPointer]
+    closure = Fiddle::Closure::BlockCaller.new(Void, param_types, &applier)
+    closure_function = Fiddle::Function.new(closure, param_types, Void)
+    CFDictionaryApplyFunction(dictionary, closure_function, NULL)
+  end
+
+  def self.CFArrayApplyBlock(array)
+    CFArrayGetCount(array).times do |index|
+      yield CFArrayGetValueAtIndex(array, index)
+    end
+  end
+
+  # @!group CFTypeRef to Ruby value conversion
+  #---------------------------------------------------------------------------#
+
+  def self.CFTypeRefToRubyValue(cf_type_reference)
+    case CFGetTypeID(cf_type_reference)
+    when CFStringGetTypeID()
+      CFStringToRubyString(cf_type_reference)
+    when CFDictionaryGetTypeID()
+      CFDictionaryToRubyHash(cf_type_reference)
+    when CFArrayGetTypeID()
+      CFArrayToRubyArray(cf_type_reference)
+    when CFBooleanGetTypeID()
+      CFBooleanToRubyBoolean(cf_type_reference)
+    else
+      description = CFStringToRubyString(CFCopyDescription(cf_type_reference))
+      raise TypeError, "Unknown type: #{description}"
+    end
+  end
+
+  def self.CFStringToRubyString(string)
+    data = CFStringCreateExternalRepresentation(NULL,
+                                                string,
+                                                KCFStringEncodingUTF8,
+                                                0)
+    if data.null?
+      raise TypeError, 'Unable to convert CFStringRef.'
+    end
+    bytes_ptr = CFDataGetBytePtr(data)
+    result = bytes_ptr.to_str(CFDataGetLength(data))
+    result.force_encoding(Encoding::UTF_8)
+    result
+  end
+
+  def self.CFDictionaryToRubyHash(dictionary)
+    result = {}
+    CFDictionaryApplyBlock(dictionary) do |key, value|
+      result[CFStringToRubyString(key)] = CFTypeRefToRubyValue(value)
+    end
+    result
+  end
+
+  def self.CFArrayToRubyArray(array)
+    result = []
+    CFArrayApplyBlock(array) do |element|
+      result << CFTypeRefToRubyValue(element)
+    end
+    result
+  end
+
+  def self.CFBooleanToRubyBoolean(boolean)
+    CFBooleanGetValue(boolean) == TRUE
+  end
+
+  # @!group Ruby value to CFTypeRef conversion
+  #---------------------------------------------------------------------------#
+
+  def self.RubyValueToCFTypeRef(value)
+    result = case value
+             when String
+               RubyStringToCFString(value)
+             when Hash
+               RubyHashToCFDictionary(value)
+             when Array
+               RubyArrayToCFArray(value)
+             when true, false
+               RubyBooleanToCFBoolean(value)
+             else
+               RubyStringToCFString(value.to_s)
+             end
+    if result.null?
+      raise TypeError, "Unable to convert Ruby value `#{value.inspect}' " \
+                       'into a CFTypeRef.'
+    end
+    result
+  end
+
+  def self.RubyStringToCFString(string)
+    CFStringCreateWithCString(NULL,
+                              Fiddle::Pointer[string],
+                              KCFStringEncodingUTF8)
+  end
+
+  def self.RubyHashToCFDictionary(hash)
+    result = CFDictionaryCreateMutable(NULL,
+                                       0,
+                                       CFTypeDictionaryKeyCallBacks(),
+                                       CFTypeDictionaryValueCallBacks())
+    hash.each do |key, value|
+      key = RubyStringToCFString(key.to_s)
+      value = RubyValueToCFTypeRef(value)
+      CFDictionaryAddValue(result, key, value)
+    end
+    result
+  end
+
+  def self.RubyArrayToCFArray(array)
+    result = CFArrayCreateMutable(NULL, 0, CFTypeArrayCallBacks())
+    array.each do |element|
+      element = RubyValueToCFTypeRef(element)
+      CFArrayAppendValue(result, element)
+    end
+    result
+  end
+
+  def self.RubyBooleanToCFBoolean(value)
+    value ? CFBooleanTrue() : CFBooleanFalse()
+  end
+
+  # rubocop:enable Style/MethodName
+  # rubocop:enable Style/VariableName
 end

data/lib/xcodeproj/project.rb

@@ -172,7 +172,7 @@ module Xcodeproj
     #
     def initialize_from_file
       pbxproj_path = path + 'project.pbxproj'
-      plist = Xcodeproj::PlistHelper.read(pbxproj_path.to_s)
+      plist = Xcodeproj.read_plist(pbxproj_path.to_s)
       root_object_uuid = plist['rootObject']
       root_object.remove_referrer(self) if root_object
       @root_object = new_from_plist(root_object_uuid, plist['objects'], self)
@@ -302,7 +302,7 @@ module Xcodeproj
       save_path ||= path
       FileUtils.mkdir_p(save_path)
       file = File.join(save_path, 'project.pbxproj')
-      Xcodeproj::PlistHelper.write(to_hash, file)
+      Xcodeproj.write_plist(to_hash, file)
       fix_encoding(file)
       XCProjHelper.touch(save_path) unless disable_xcproj?
     end
@@ -701,7 +701,7 @@ module Xcodeproj
       end
 
       xcschememanagement_path = schemes_dir + 'xcschememanagement.plist'
-      Xcodeproj::PlistHelper.write(xcschememanagement, xcschememanagement_path)
+      Xcodeproj.write_plist(xcschememanagement, xcschememanagement_path)
     end
 
     #-------------------------------------------------------------------------#

data/lib/xcodeproj/project/object/helpers/file_references_factory.rb

@@ -139,7 +139,7 @@ module Xcodeproj
                   new_file_reference(ref, child_path, :group)
                 elsif File.basename(child_path) == '.xccurrentversion'
                   full_path = path + File.basename(child_path)
-                  xccurrentversion = Xcodeproj::PlistHelper.read(full_path)
+                  xccurrentversion = Xcodeproj.read_plist(full_path)
                   current_version_name = xccurrentversion['_XCCurrentVersionName']
                 end
               end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xcodeproj
 version: !ruby/object:Gem::Version
-  version: 0.19.2
+  version: 0.19.3
 platform: ruby
 authors:
 - Eloy Duran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-25 00:00:00.000000000 Z
+date: 2014-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -38,20 +38,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
-- !ruby/object:Gem::Dependency
-  name: CFPropertyList
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.2'
 description: Xcodeproj lets you create and modify Xcode projects from Ruby. Script
   boring management tasks or build Xcode-friendly libraries. Also includes support
   for Xcode workspaces (.xcworkspace) and configuration files (.xcconfig).
@@ -63,6 +49,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - LICENSE
+- ext/xcodeproj/xcodeproj_ext.bundle
 - lib/xcodeproj/command/project_diff.rb
 - lib/xcodeproj/command/show.rb
 - lib/xcodeproj/command/sort.rb