xcodeproj 0.28.2 → 1.0.0.beta.1

data/lib/xcodeproj/scheme/launch_action.rb

@@ -62,6 +62,22 @@ module Xcodeproj
         @xml_element.add_element(runnable.xml_element) if runnable
       end
 
+      # @return [EnvironmentVariables]
+      #         Returns the EnvironmentVariables that will be defined at app launch
+      #
+      def environment_variables
+        EnvironmentVariables.new(@xml_element.elements[XCScheme::VARIABLES_NODE])
+      end
+
+      # @param [EnvironmentVariables,nil] env_vars
+      #        Sets the EnvironmentVariables that will be defined at app launch
+      #
+      def environment_variables=(env_vars)
+        @xml_element.delete_element(XCScheme::VARIABLES_NODE)
+        @xml_element.add_element(env_vars.xml_element) if env_vars
+        env_vars
+      end
+
       # @todo handle 'AdditionalOptions' tag
     end
   end

data/lib/xcodeproj/scheme/test_action.rb

@@ -1,4 +1,5 @@
 require 'xcodeproj/scheme/abstract_scheme_action'
+require 'xcodeproj/scheme/environment_variables'
 
 module Xcodeproj
   class XCScheme
@@ -84,6 +85,23 @@ module Xcodeproj
         @xml_element.add_element(macro_expansion.xml_element)
       end
 
+      # @return [EnvironmentVariables]
+      #         Returns the EnvironmentVariables that will be defined at test launch
+      #
+      def environment_variables
+        EnvironmentVariables.new(@xml_element.elements[XCScheme::VARIABLES_NODE])
+      end
+
+      # @param [EnvironmentVariables,nil] env_vars
+      #        Sets the EnvironmentVariables that will be defined at test launch
+      # @return [EnvironmentVariables]
+      #
+      def environment_variables=(env_vars)
+        @xml_element.delete_element(XCScheme::VARIABLES_NODE)
+        @xml_element.add_element(env_vars.xml_element) if env_vars
+        env_vars
+      end
+
       #-------------------------------------------------------------------------#
 
       class TestableReference < XMLElementWrapper

data/lib/xcodeproj/workspace.rb

@@ -1,24 +1,54 @@
 require 'fileutils'
 require 'rexml/document'
 require 'xcodeproj/workspace/file_reference'
+require 'xcodeproj/workspace/group_reference'
 
 module Xcodeproj
   # Provides support for generating, reading and serializing Xcode Workspace
   # documents.
   #
   class Workspace
-    # @return [Array<String>] the paths of the projects contained in the
+    # @return [REXML::Document] the parsed XML model for the workspace contents
+    attr_reader :document
+
+    # @return [Hash<String => String>] a mapping from scheme name to project full path
+    #         containing the scheme
+    attr_reader :schemes
+
     # @return [Array<FileReference>] the paths of the projects contained in the
     #         workspace.
     #
-    attr_reader :file_references
-    attr_reader :schemes
+    def file_references
+      return [] unless @document
+      @document.get_elements('/Workspace//FileRef').map do |node|
+        FileReference.from_node(node)
+      end
+    end
+
+    # @return [Array<GroupReference>] the groups contained in the workspace
+    #
+    def group_references
+      return [] unless @document
+      @document.get_elements('/Workspace//Group').map do |node|
+        GroupReference.from_node(node)
+      end
+    end
 
-    # @param  [Array] file_references @see file_references
+    # @param [REXML::Document] document @see document
+    # @param [Array<FileReference>] file_references additional projects to add
+    #
+    # @note The document parameter is passed to the << operator if it is not a
+    #       valid REXML::Document. It is optional, but may also be passed as nil
     #
-    def initialize(*file_references)
-      @file_references = file_references.flatten
+    def initialize(document, *file_references)
       @schemes = {}
+      if document.nil? || document.is_a?(REXML::Document)
+        @document = document
+      else
+        @document = REXML::Document.new(root_xml(''))
+        self << document
+      end
+      file_references.each { |ref| self << ref }
     end
 
     #-------------------------------------------------------------------------#
@@ -31,9 +61,10 @@ module Xcodeproj
     # @return [Workspace] the generated workspace.
     #
     def self.new_from_xcworkspace(path)
-      from_s(File.read(File.join(path, 'contents.xcworkspacedata')), File.expand_path(File.dirname(path)))
+      from_s(File.read(File.join(path, 'contents.xcworkspacedata')),
+             File.expand_path(File.dirname(path)))
     rescue Errno::ENOENT
-      new
+      new(nil)
     end
 
     #-------------------------------------------------------------------------#
@@ -48,28 +79,53 @@ module Xcodeproj
     #
     def self.from_s(xml, workspace_path = '')
       document = REXML::Document.new(xml)
-      file_references = document.get_elements('/Workspace/FileRef').map do |node|
-        FileReference.from_node(node)
-      end
-      instance = new(file_references)
+      instance = new(document)
       instance.load_schemes(workspace_path)
       instance
     end
 
-    #-------------------------------------------------------------------------#
-
     # Adds a new path to the list of the of projects contained in the
     # workspace.
+    # @param [String, Xcodeproj::Workspace::FileReference] path_or_reference
+    #        A string or Xcode::Workspace::FileReference containing a path to an Xcode project
     #
-    # @param  [String] projpath
-    #         The path of the project to add.
+    # @raise [ArgumentError] Raised if the input is neither a String nor a FileReference
     #
     # @return [void]
     #
-    def <<(projpath)
-      project_file_reference = Xcodeproj::Workspace::FileReference.new(projpath)
-      @file_references << project_file_reference
-      load_schemes_from_project File.expand_path(projpath)
+    def <<(path_or_reference)
+      return unless @document && @document.respond_to?(:root)
+      case
+      when path_or_reference.is_a?(String)
+        project_file_reference = Xcodeproj::Workspace::FileReference.new(path_or_reference)
+      when path_or_reference.is_a?(Xcodeproj::Workspace::FileReference)
+        project_file_reference = path_or_reference
+        projpath = nil
+      else
+        raise ArgumentError, 'Input to the << operator must be a file path or FileReference'
+      end
+      @document.root.add_element(project_file_reference.to_node)
+      load_schemes_from_project File.expand_path(projpath || project_file_reference.path)
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # Adds a new group container to the workspace
+    # workspace.
+    #
+    # @param  [String] name The name of the group
+    #
+    # @yield [Xcodeproj::Workspace::GroupReference, REXML::Element]
+    #        Yields the GroupReference and underlying XML element for mutation
+    #
+    # @return [Xcodeproj::Workspace::GroupReference] The added group reference
+    #
+    def add_group(name)
+      return nil unless @document
+      group = Xcodeproj::Workspace::GroupReference.new(name)
+      elem = @document.root.add_element(group.to_node)
+      yield group, elem if block_given?
+      group
     end
 
     # Checks if the workspace contains the project with the given file
@@ -81,14 +137,32 @@ module Xcodeproj
     # @return [Boolean] whether the project is contained in the workspace.
     #
     def include?(file_reference)
-      @file_references.include?(file_reference)
+      file_references.include?(file_reference)
     end
 
     # @return [String] the XML representation of the workspace.
     #
     def to_s
-      contents = file_references.map { |reference| file_reference_xml(reference) }
-      root_xml(contents.join(''))
+      contents = ''
+      stack = []
+      @document.root.each_recursive do |elem|
+        until stack.empty?
+          last = stack.last
+          break if last == elem.parent
+          contents += xcworkspace_element_end_xml(stack.length, last)
+          stack.pop
+        end
+
+        stack << elem
+        contents += xcworkspace_element_start_xml(stack.length, elem)
+      end
+
+      until stack.empty?
+        contents += xcworkspace_element_end_xml(stack.length, stack.last)
+        stack.pop
+      end
+
+      root_xml(contents)
     end
 
     # Saves the workspace at the given `xcworkspace` path.
@@ -115,7 +189,7 @@ module Xcodeproj
     # @return [void]
     #
     def load_schemes(workspace_dir_path)
-      @file_references.each do |file_reference|
+      file_references.each do |file_reference|
         project_full_path = file_reference.absolute_path(workspace_dir_path)
         load_schemes_from_project(project_full_path)
       end
@@ -146,21 +220,38 @@ module Xcodeproj
 <?xml version="1.0" encoding="UTF-8"?>
 <Workspace
    version = "1.0">
-   #{contents.strip}
+#{contents.rstrip}
 </Workspace>
-      DOC
+DOC
     end
 
-    # @return [String] The XML representation of a file reference.
     #
-    # @param  [FileReference] file_reference The file reference.
+    # @param  [Integer] depth The depth of the element in the tree
+    # @param  [REXML::Document::Element] elem The XML element to format.
     #
-    def file_reference_xml(file_reference)
-      <<-DOC
-   <FileRef
-      location = "#{file_reference.type}:#{file_reference.path}">
-   </FileRef>
-      DOC
+    # @return [String] The Xcode-specific XML formatting of an element start
+    #
+    def xcworkspace_element_start_xml(depth, elem)
+      attributes = case elem.name
+                   when 'Group'
+                     %w(location name)
+                   when 'FileRef'
+                     %w(location)
+                   end
+      contents = "<#{elem.name}"
+      indent = '   ' * depth
+      attributes.each { |name| contents += "\n   #{name} = \"#{elem.attribute(name)}\"" }
+      contents.split("\n").map { |line| "#{indent}#{line}" }.join("\n") + ">\n"
+    end
+
+    #
+    # @param  [Integer] depth The depth of the element in the tree
+    # @param  [REXML::Document::Element] elem The XML element to format.
+    #
+    # @return [String] The Xcode-specific XML formatting of an element end
+    #
+    def xcworkspace_element_end_xml(depth, elem)
+      "#{'   ' * depth}</#{elem.name}>\n"
     end
 
     #-------------------------------------------------------------------------#

data/lib/xcodeproj/workspace/group_reference.rb

@@ -0,0 +1,64 @@
+module Xcodeproj
+  class Workspace
+    # Describes a group reference of a Workspace.
+    #
+    class GroupReference
+      # @return [String] the name of the group
+      #
+      attr_reader :name
+
+      # @return [String] the type of reference to the project
+      #
+      # This can be of the following values:
+      # - absolute
+      # - group
+      # - container (only supported value)
+      # - developer
+      #
+      attr_reader :type
+
+      # @param [#to_s] name @see name
+      # @param [#to_s] type @see type
+      #
+      def initialize(name, type = 'container')
+        @name = name.to_s
+        @type = type.to_s
+      end
+
+      # @return [Bool] Whether a group reference is equal to another.
+      #
+      def ==(other)
+        name == other.name && type == other.type
+      end
+      alias_method :eql?, :==
+
+      # @return [Fixnum] A hash identical for equals objects.
+      #
+      def hash
+        [name, type].hash
+      end
+
+      # Returns a group reference given XML representation.
+      #
+      # @param  [REXML::Element] xml_node
+      #         the XML representation.
+      #
+      # @return [GroupReference] The new group reference instance.
+      #
+      def self.from_node(xml_node)
+        type = xml_node.attribute('location').value.split(':', 2).first
+        name = xml_node.attribute('name').value
+        new(name, type)
+      end
+
+      # @return [REXML::Element] the XML representation of the group reference.
+      #
+      def to_node
+        REXML::Element.new('Group').tap do |element|
+          element.add_attribute('location', "#{type}:")
+          element.add_attribute('name', "#{name}")
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xcodeproj
 version: !ruby/object:Gem::Version
-  version: 0.28.2
+  version: 1.0.0.beta.1
 platform: ruby
 authors:
 - Eloy Duran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-09 00:00:00.000000000 Z
+date: 2015-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -61,22 +61,30 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- README.md
 - LICENSE
+- README.md
+- bin/xcodeproj
+- lib/xcodeproj.rb
+- lib/xcodeproj/command.rb
 - lib/xcodeproj/command/config_dump.rb
 - lib/xcodeproj/command/project_diff.rb
 - lib/xcodeproj/command/show.rb
 - lib/xcodeproj/command/sort.rb
 - lib/xcodeproj/command/target_diff.rb
-- lib/xcodeproj/command.rb
-- lib/xcodeproj/config/other_linker_flags_parser.rb
 - lib/xcodeproj/config.rb
+- lib/xcodeproj/config/other_linker_flags_parser.rb
 - lib/xcodeproj/constants.rb
 - lib/xcodeproj/differ.rb
 - lib/xcodeproj/gem_version.rb
 - lib/xcodeproj/helper.rb
-- lib/xcodeproj/plist_helper.rb
+- lib/xcodeproj/plist.rb
+- lib/xcodeproj/plist/ffi.rb
+- lib/xcodeproj/plist/ffi/core_foundation.rb
+- lib/xcodeproj/plist/ffi/dev_tools_core.rb
+- lib/xcodeproj/plist/plist_gem.rb
+- lib/xcodeproj/project.rb
 - lib/xcodeproj/project/case_converter.rb
+- lib/xcodeproj/project/object.rb
 - lib/xcodeproj/project/object/build_configuration.rb
 - lib/xcodeproj/project/object/build_file.rb
 - lib/xcodeproj/project/object/build_phase.rb
@@ -91,31 +99,29 @@ files:
 - lib/xcodeproj/project/object/reference_proxy.rb
 - lib/xcodeproj/project/object/root_object.rb
 - lib/xcodeproj/project/object/target_dependency.rb
-- lib/xcodeproj/project/object.rb
 - lib/xcodeproj/project/object_attributes.rb
 - lib/xcodeproj/project/object_dictionary.rb
 - lib/xcodeproj/project/object_list.rb
 - lib/xcodeproj/project/project_helper.rb
 - lib/xcodeproj/project/uuid_generator.rb
-- lib/xcodeproj/project.rb
+- lib/xcodeproj/scheme.rb
 - lib/xcodeproj/scheme/abstract_scheme_action.rb
 - lib/xcodeproj/scheme/analyze_action.rb
 - lib/xcodeproj/scheme/archive_action.rb
 - lib/xcodeproj/scheme/build_action.rb
 - lib/xcodeproj/scheme/buildable_product_runnable.rb
 - lib/xcodeproj/scheme/buildable_reference.rb
+- lib/xcodeproj/scheme/environment_variables.rb
 - lib/xcodeproj/scheme/launch_action.rb
 - lib/xcodeproj/scheme/macro_expansion.rb
 - lib/xcodeproj/scheme/profile_action.rb
 - lib/xcodeproj/scheme/test_action.rb
 - lib/xcodeproj/scheme/xml_element_wrapper.rb
-- lib/xcodeproj/scheme.rb
 - lib/xcodeproj/user_interface.rb
-- lib/xcodeproj/workspace/file_reference.rb
 - lib/xcodeproj/workspace.rb
+- lib/xcodeproj/workspace/file_reference.rb
+- lib/xcodeproj/workspace/group_reference.rb
 - lib/xcodeproj/xcodebuild_helper.rb
-- lib/xcodeproj.rb
-- bin/xcodeproj
 homepage: https://github.com/cocoapods/xcodeproj
 licenses:
 - MIT
@@ -136,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 3
 summary: Create and modify Xcode projects from Ruby.

data/lib/xcodeproj/plist_helper.rb

@@ -1,758 +0,0 @@
-begin
-  require 'fiddle'
-rescue LoadError
-  message = 'Xcodeproj relies on a library called `fiddle` to read and write ' \
-            'Xcode project files. Ensure your Ruby installation includes ' \
-            '`fiddle` and try again.'
-  raise Xcodeproj::Informative, message
-end
-
-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.
-  #
-  module PlistHelper
-    class << self
-      # Serializes a hash as an XML property list file.
-      #
-      # @param  [#to_hash] hash
-      #         The hash to store.
-      #
-      # @param  [#to_s] path
-      #         The path of the file.
-      #
-      def write(possible_hash, path)
-        if possible_hash.respond_to?(:to_hash)
-          hash = possible_hash.to_hash
-        else
-          raise TypeError, "The given `#{possible_hash.inspect}` must respond " \
-                            "to #to_hash'."
-        end
-
-        unless path.is_a?(String) || path.is_a?(Pathname)
-          raise TypeError, "The given `#{path}` must be a string or 'pathname'."
-        end
-        path = path.to_s
-        raise IOError, 'Empty path.' if path == ''
-
-        if DevToolsCore.load_xcode_frameworks && path.end_with?('pbxproj')
-          ruby_hash_write_xcode(hash, path)
-        else
-          CoreFoundation.RubyHashPropertyListWrite(hash, path)
-          fix_encoding(path)
-        end
-      end
-
-      # @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 Informative, "The plist file at path `#{path}` doesn't exist."
-        end
-        if file_in_conflict?(path)
-          raise Informative, "The file `#{path}` is in a merge conflict."
-        end
-        CoreFoundation.RubyHashPropertyListRead(path)
-      end
-
-      private
-
-      # Simple workaround to escape characters which are outside of ASCII
-      # character-encoding. Relies on the fact that there are no XML characters
-      # which would need to be escaped.
-      #
-      # @note   This is necessary because Xcode (4.6 currently) uses the MacRoman
-      #         encoding unless the `// !$*UTF8*$!` magic comment is present. It
-      #         is not possible to serialize a plist using the NeXTSTEP format
-      #         without access to the private classes of Xcode and that comment
-      #         is not compatible with the XML format. For the complete
-      #         discussion see CocoaPods/CocoaPods#926.
-      #
-      #
-      # @note   Sadly this hack is not sufficient for supporting Emoji.
-      #
-      # @param  [String, Pathname] The path of the file which needs to be fixed.
-      #
-      # @return [void]
-      #
-      def fix_encoding(filename)
-        output = ''
-        input = File.open(filename, 'rb') { |file| file.read }
-        input.unpack('U*').each do |codepoint|
-          if codepoint > 127 # ASCII is 7-bit, so 0-127 are valid characters
-            output << "&##{codepoint};"
-          else
-            output << codepoint.chr
-          end
-        end
-        File.open(filename, 'wb') { |file| file.write(output) }
-      end
-
-      # @return [Bool] Checks whether there are merge conflicts in the file.
-      #
-      # @param  [#to_s] path
-      #         The path of the file.
-      #
-      def file_in_conflict?(path)
-        file = File.open(path)
-        file.each_line.any? { |l| l.match(/^(<|=|>){7}/) }
-      ensure
-        file.close
-      end
-
-      # Serializes a hash as an ASCII plist, using Xcode.
-      #
-      # @param  [Hash] hash
-      #         The hash to store.
-      #
-      # @param  [String] path
-      #         The path of the file.
-      #
-      def ruby_hash_write_xcode(hash, path)
-        path = File.expand_path(path)
-        success = true
-
-        begin
-          plist = DevToolsCore::CFDictionary.new(CoreFoundation.RubyHashToCFDictionary(hash))
-          data = DevToolsCore::NSData.new(plist.plistDescriptionUTF8Data)
-          success &= data.writeToFileAtomically(path)
-
-          project = DevToolsCore::PBXProject.new(path)
-          success &= project.writeToFileSystemProjectFile
-          project.close
-        rescue Fiddle::DLError
-          success = false
-        end
-
-        CoreFoundation.RubyHashPropertyListWrite(hash, path) unless success
-      end
-    end
-  end
-end
-
-# 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.
-#
-# @!visibility private
-#
-module CoreFoundation
-  PATH = '/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation'
-
-  # rubocop:disable Style/MethodName
-  # rubocop:disable Style/VariableName
-
-  # @!group Ruby hash as property list (de)serialization
-  #---------------------------------------------------------------------------#
-
-  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
-
-    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
-
-  SINT64_MAX = 2**63 - 1
-  SINT64_MIN = -SINT64_MAX - 1
-
-  SIZEOF_SINT64 = 8
-  SIZEOF_FLOAT64 = 8
-
-  SINT64_PACK_TEMPLATE = 'q'
-  FLOAT64_PACK_TEMPLATE = 'd'
-
-  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
-
-  CFNumberType = Fiddle::TYPE_INT
-  KCFNumberSInt64Type = 4
-  KCFNumberFloat64Type = 6
-
-  # rubocop:enable Style/ConstantName
-
-  private
-
-  # @!group Helpers
-  #---------------------------------------------------------------------------#
-
-  def self.image
-    @image ||= Fiddle.dlopen(PATH)
-  end
-
-  def self.free_function
-    @free_function ||= Fiddle::Function.new(Fiddle::Handle.new['free'], [VoidPointer], Void)
-  end
-
-  def self.CFRelease_function
-    @CFRelease ||= Fiddle::Function.new(image['CFRelease'], [CFTypeRef], Void)
-  end
-
-  def self.extern_image(image, 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
-
-      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
-
-  def self.extern(symbol, parameter_types, return_type)
-    extern_image(image, symbol, parameter_types, return_type)
-  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
-  extern :CFNumberGetTypeID, [], 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
-
-  # CFNumber
-  extern :CFNumberIsFloatType, [CFTypeRef], Boolean
-  extern :CFNumberGetValue, [CFTypeRef, CFNumberType, VoidPointer], Boolean
-  extern :CFNumberCreate,  [CFTypeRef, CFNumberType, VoidPointer], CFTypeRef
-
-  # @!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.
-  #
-  # @note This means that the object will *not* be released if it's not
-  #       dereferenced, but that would be a leak anyways, so be sure to do so.
-  #
-  def self.CFTypeRefPointer
-    pointer = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INTPTR_T, free_function)
-    def pointer.ptr
-      ::CoreFoundation.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)
-    when CFNumberGetTypeID()
-      CFNumberToRubyNumber(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
-
-  def self.CFNumberToRubyNumber(number)
-    if CFNumberIsFloatType(number) == FALSE
-      value_type = KCFNumberSInt64Type
-      pack_template = SINT64_PACK_TEMPLATE
-      size = SIZEOF_SINT64
-    else
-      value_type = KCFNumberFloat64Type
-      pack_template = FLOAT64_PACK_TEMPLATE
-      size = SIZEOF_FLOAT64
-    end
-    ptr = Fiddle::Pointer.malloc(size)
-    CFNumberGetValue(number, value_type, ptr)
-    ptr.to_str.unpack(pack_template).first
-  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)
-             when Numeric
-               RubyNumberToCFNumber(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.RubyNumberToCFNumber(value)
-    case value
-    when Float
-      value_type = KCFNumberFloat64Type
-      pack_template = FLOAT64_PACK_TEMPLATE
-    when SINT64_MIN..SINT64_MAX
-      value_type = KCFNumberSInt64Type
-      pack_template = SINT64_PACK_TEMPLATE
-    else # the value is too big to be stored in a CFNumber so store it as a CFString
-      return RubyStringToCFString(value.to_s)
-    end
-    ptr = Fiddle::Pointer.to_ptr([value].pack(pack_template))
-    CFNumberCreate(NULL, value_type, ptr)
-  end
-
-  def self.RubyBooleanToCFBoolean(value)
-    value ? CFBooleanTrue() : CFBooleanFalse()
-  end
-
-  # rubocop:enable Style/MethodName
-  # rubocop:enable Style/VariableName
-end
-
-module DevToolsCore
-  def self.silence_stderr
-    begin
-      orig_stderr = $stderr.clone
-      $stderr.reopen File.new('/dev/null', 'w')
-      retval = yield
-    ensure
-      $stderr.reopen orig_stderr
-    end
-    retval
-  end
-
-  # rubocop:disable Style/MethodName
-  # rubocop:disable Style/VariableName
-
-  class NSObject
-    private
-
-    def self.objc_class
-      @objc_class ||= CoreFoundation.objc_getClass(name.split('::').last)
-    end
-
-    def self.image
-      @image ||= Fiddle::Handle.new
-    end
-
-    def self.extern(symbol, parameter_types, return_type)
-      CoreFoundation.extern_image(image, symbol, parameter_types, return_type)
-    end
-
-    def self.objc_msgSend(args, return_type = CoreFoundation::VoidPointer)
-      arguments = [CoreFoundation::VoidPointer, CoreFoundation::VoidPointer] + args
-
-      Fiddle::Function.new(image['objc_msgSend'], arguments, return_type)
-    end
-
-    def self.respondsToSelector(instance, sel)
-      selector = CoreFoundation.NSSelectorFromString(CoreFoundation.RubyStringToCFString(sel))
-      respondsToSelector = objc_msgSend([CoreFoundation::CharPointer], CoreFoundation::Boolean)
-      result = respondsToSelector.call(
-        instance,
-        CoreFoundation.NSSelectorFromString(CoreFoundation.RubyStringToCFString('respondsToSelector:')),
-        selector)
-      result == CoreFoundation::TRUE ? true : false
-    end
-
-    Class = CoreFoundation::VoidPointer
-    ID = CoreFoundation::VoidPointer
-    SEL = CoreFoundation::VoidPointer
-
-    extern :NSSelectorFromString, [CoreFoundation::CFTypeRef], SEL
-
-    extern :objc_getClass, [CoreFoundation::CharPointer], Class
-    extern :class_getName, [Class], CoreFoundation::CharPointer
-  end
-
-  XCODE_PATH = Pathname.new(`xcrun xcode-select --print-path`.strip).dirname
-
-  def self.load_xcode_framework(framework)
-    Fiddle.dlopen(XCODE_PATH.join(framework).to_s)
-    rescue Fiddle::DLError
-      nil
-  end
-
-  # @note The IB frameworks only seem to be necessary on Xcode 7+
-  #
-  def self.load_xcode_frameworks
-    DevToolsCore.silence_stderr do
-      load_xcode_framework('SharedFrameworks/DVTFoundation.framework/DVTFoundation')
-      load_xcode_framework('SharedFrameworks/DVTSourceControl.framework/DVTSourceControl')
-      load_xcode_framework('SharedFrameworks/CSServiceClient.framework/CSServiceClient')
-      load_xcode_framework('Frameworks/IBFoundation.framework/IBFoundation')
-      load_xcode_framework('Frameworks/IBAutolayoutFoundation.framework/IBAutolayoutFoundation')
-      load_xcode_framework('Frameworks/IDEFoundation.framework/IDEFoundation')
-      load_xcode_framework('PlugIns/Xcode3Core.ideplugin/Contents/MacOS/Xcode3Core')
-    end
-  end
-
-  class CFDictionary < NSObject
-    public
-
-    def initialize(dictionary)
-      @dictionary = dictionary
-    end
-
-    def plistDescriptionUTF8Data
-      selector = 'plistDescriptionUTF8Data'
-      return nil unless NSObject.respondsToSelector(@dictionary, selector)
-
-      plistDescriptionUTF8Data = CFDictionary.objc_msgSend([])
-      plistDescriptionUTF8Data.call(
-        @dictionary,
-        CoreFoundation.NSSelectorFromString(CoreFoundation.RubyStringToCFString(selector)))
-    end
-
-    def self.image
-      @image ||= DevToolsCore.load_xcode_frameworks
-    end
-  end
-
-  class NSData < NSObject
-    public
-
-    def initialize(data)
-      @data = data
-    end
-
-    def writeToFileAtomically(path)
-      selector = 'writeToFile:atomically:'
-      return false unless NSObject.respondsToSelector(@data, selector)
-
-      writeToFileAtomically = NSData.objc_msgSend([CoreFoundation::VoidPointer, CoreFoundation::Boolean], CoreFoundation::Boolean)
-      result = writeToFileAtomically.call(
-        @data,
-        CoreFoundation.NSSelectorFromString(CoreFoundation.RubyStringToCFString(selector)),
-        CoreFoundation.RubyStringToCFString(path),
-        1)
-      result == CoreFoundation::TRUE ? true : false
-    end
-  end
-
-  class PBXProject < NSObject
-    public
-
-    def initialize(path)
-      DevToolsCore.silence_stderr do
-        CoreFoundation.IDEInitialize(1, CoreFoundation::NULL)
-
-        # The parameter is whether UI must be initialized (which we don't need)
-        CoreFoundation.XCInitializeCoreIfNeeded(0)
-      end
-
-      selector = 'projectWithFile:'
-
-      if NSObject.respondsToSelector(PBXProject.objc_class, selector)
-        projectWithFile = PBXProject.objc_msgSend([CoreFoundation::VoidPointer])
-        @project = projectWithFile.call(
-          PBXProject.objc_class,
-          CoreFoundation.NSSelectorFromString(CoreFoundation.RubyStringToCFString(selector)),
-          CoreFoundation.RubyStringToCFString(path))
-      end
-    end
-
-    def close
-      selector = 'close'
-      return unless NSObject.respondsToSelector(@project, selector)
-
-      close = PBXProject.objc_msgSend([], CoreFoundation::Void)
-      close.call(@project, CoreFoundation.NSSelectorFromString(CoreFoundation.RubyStringToCFString(selector)))
-    end
-
-    def writeToFileSystemProjectFile
-      selector = 'writeToFileSystemProjectFile:userFile:checkNeedsRevert:'
-      return unless NSObject.respondsToSelector(@project, selector)
-
-      writeToFile = PBXProject.objc_msgSend([CoreFoundation::Boolean, CoreFoundation::Boolean, CoreFoundation::Boolean], CoreFoundation::Boolean)
-      result = writeToFile.call(
-        @project,
-        CoreFoundation.NSSelectorFromString(CoreFoundation.RubyStringToCFString(selector)),
-        1,
-        0,
-        1)
-      result == CoreFoundation::TRUE ? true : false
-    end
-
-    private
-
-    def self.image
-      @image ||= DevToolsCore.load_xcode_frameworks
-    end
-
-    extern :IDEInitialize, [CoreFoundation::Boolean, ID], CoreFoundation::Void
-    extern :XCInitializeCoreIfNeeded, [CoreFoundation::Boolean], CoreFoundation::Void
-  end
-
-  # rubocop:enable Style/MethodName
-  # rubocop:enable Style/VariableName
-end