cocoapods-dependency-html 0.0.1

data/vendor/bundle/gems/xcodeproj-1.9.0/lib/xcodeproj/differ.rb

@@ -0,0 +1,239 @@
+module Xcodeproj
+  # Computes the recursive diff of Hashes, Array and other objects.
+  #
+  # Useful to compare two projects. Inspired from
+  # 'active_support/core_ext/hash/diff'.
+  #
+  # @example
+  #   h1 = { :common => 'value', :changed => 'v1' }
+  #   h2 = { :common => 'value', :changed => 'v2', :addition => 'new_value' }
+  #   h1.recursive_diff(h2) == {
+  #     :changed => {
+  #       :self  => 'v1',
+  #       :other => 'v2'
+  #     },
+  #     :addition => {
+  #       :self  => nil,
+  #       :other => 'new_value'
+  #     }
+  #   } #=> true
+  #
+  #
+  #
+  #
+  module Differ
+    # Computes the recursive difference of two given values.
+    #
+    # @param  [Object] value_1
+    #         The first value to compare.
+    #
+    # @param  [Object] value_2
+    #         The second value to compare.
+    #
+    # @param  [Object] key_1
+    #         The key for the diff of value_1.
+    #
+    # @param  [Object] key_2
+    #         The key for the diff of value_2.
+    #
+    # @param  [Object] id_key
+    #         The key used to identify correspondent hashes in an array.
+    #
+    # @return [Hash] The diff
+    # @return [Nil] if the given values are equal.
+    #
+    def self.diff(value_1, value_2, options = {})
+      options[:key_1] ||= 'value_1'
+      options[:key_2] ||= 'value_2'
+      options[:id_key] ||= nil
+
+      method = if value_1.class == value_2.class
+                 case value_1
+                 when Hash  then :hash_diff
+                 when Array then :array_diff
+                 else :generic_diff
+                 end
+               else
+                 :generic_diff
+               end
+      send(method, value_1, value_2, options)
+    end
+
+    # Optimized for reducing the noise from the tree hash of projects
+    #
+    def self.project_diff(project_1, project_2, key_1 = 'project_1', key_2 = 'project_2')
+      project_1 = project_1.to_tree_hash unless project_1.is_a?(Hash)
+      project_2 = project_2.to_tree_hash unless project_2.is_a?(Hash)
+      options = {
+        :key_1  => key_1,
+        :key_2  => key_2,
+        :id_key => 'displayName',
+      }
+      diff(project_1, project_2, options)
+    end
+
+    #-------------------------------------------------------------------------#
+
+    public
+
+    # @!group Type specific handlers
+
+    # Computes the recursive difference of two hashes.
+    #
+    # @see diff
+    #
+    def self.hash_diff(value_1, value_2, options)
+      ensure_class(value_1, Hash)
+      ensure_class(value_2, Hash)
+      return nil if value_1 == value_2
+
+      result = {}
+      all_keys = (value_1.keys + value_2.keys).uniq
+      all_keys.each do |key|
+        key_value_1 = value_1[key]
+        key_value_2 = value_2[key]
+        diff = diff(key_value_1, key_value_2, options)
+        if diff
+          result[key] = diff if diff
+        end
+      end
+      if result.empty?
+        nil
+      else
+        result
+      end
+    end
+
+    # Returns the recursive diff of two arrays.
+    #
+    # @see diff
+    #
+    def self.array_diff(value_1, value_2, options)
+      ensure_class(value_1, Array)
+      ensure_class(value_2, Array)
+      return nil if value_1 == value_2
+
+      new_objects_value_1 = (value_1 - value_2)
+      new_objects_value_2 = (value_2 - value_1)
+      return nil if value_1.empty? && value_2.empty?
+
+      matched_diff = {}
+      if id_key = options[:id_key]
+        matched_value_1 = []
+        matched_value_2 = []
+        new_objects_value_1.each do |entry_value_1|
+          if entry_value_1.is_a?(Hash)
+            id_value = entry_value_1[id_key]
+            entry_value_2 = new_objects_value_2.find do |entry|
+              entry[id_key] == id_value
+            end
+            if entry_value_2
+              matched_value_1 << entry_value_1
+              matched_value_2 << entry_value_2
+              diff = diff(entry_value_1, entry_value_2, options)
+              matched_diff[id_value] = diff if diff
+            end
+          end
+        end
+
+        new_objects_value_1 -= matched_value_1
+        new_objects_value_2 -= matched_value_2
+      end
+
+      if new_objects_value_1.empty? && new_objects_value_2.empty?
+        if matched_diff.empty?
+          nil
+        else
+          matched_diff
+        end
+      else
+        result = {}
+        result[options[:key_1]] = new_objects_value_1 unless new_objects_value_1.empty?
+        result[options[:key_2]] = new_objects_value_2 unless new_objects_value_2.empty?
+        result[:diff] = matched_diff unless matched_diff.empty?
+        result
+      end
+    end
+
+    # Returns the diff of two generic objects.
+    #
+    # @see diff
+    #
+    def self.generic_diff(value_1, value_2, options)
+      return nil if value_1 == value_2
+
+      {
+        options[:key_1] => value_1,
+        options[:key_2] => value_2,
+      }
+    end
+
+    #-------------------------------------------------------------------------#
+
+    public
+
+    # @!group Cleaning
+
+    # Returns a copy of the hash where the given key is removed recursively.
+    #
+    # @param  [Hash] hash
+    #         The hash to clean
+    #
+    # @param  [Object] key
+    #         The key to remove.
+    #
+    # @return [Hash] A copy of the hash without the key.
+    #
+    def self.clean_hash(hash, key)
+      new_hash = hash.dup
+      self.clean_hash!(new_hash, key)
+      new_hash
+    end
+
+    # Recursively cleans a key from the given hash.
+    #
+    # @param  [Hash] hash
+    #         The hash to clean
+    #
+    # @param  [Object] key
+    #         The key to remove.
+    #
+    # @return [void]
+    #
+    def self.clean_hash!(hash, key)
+      hash.delete(key)
+      hash.each do |_, value|
+        case value
+        when Hash
+          clean_hash!(value, key)
+        when Array
+          value.each { |entry| clean_hash!(entry, key) if entry.is_a?(Hash) }
+        end
+      end
+    end
+
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # @! Helpers
+
+    # Ensures that the given object belongs to the given class.
+    #
+    # @param  [Object] object
+    #         The object to check.
+    #
+    # @param  [Class] klass
+    #         the expected class of the object.
+    #
+    # @raise  If the object doesn't belong to the given class.
+    #
+    # @return [void]
+    #
+    def self.ensure_class(object, klass)
+      raise "Wrong type `#{object.inspect}`" unless object.is_a?(klass)
+    end
+
+    #-------------------------------------------------------------------------#
+  end
+end

data/vendor/bundle/gems/xcodeproj-1.9.0/lib/xcodeproj/gem_version.rb

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

data/vendor/bundle/gems/xcodeproj-1.9.0/lib/xcodeproj/helper.rb

@@ -0,0 +1,30 @@
+module Xcodeproj
+  module Helper
+    class TargetDiff
+      attr_reader :project, :target1, :target2
+
+      def initialize(project, target1_name, target2_name)
+        @project = project
+        unless @target1 = @project.targets.find { |target| target.name == target1_name }
+          raise ArgumentError, "Target 1 by name `#{target1_name}' not found in the project."
+        end
+        unless @target2 = @project.targets.find { |target| target.name == target2_name }
+          raise ArgumentError, "Target 1 by name `#{target2_name}' not found in the project."
+        end
+      end
+
+      # @return [Array<PBXBuildFile>] A list of source files (that will be
+      #         compiled) which are in ‘target 2’ but not in ‘target 1’. The
+      #         list is sorted by file path.
+      #
+      def new_source_build_files
+        new = @target2.source_build_phase.files.reject do |target2_build_file|
+          @target1.source_build_phase.files.any? do |target1_build_file|
+            target1_build_file.file_ref.path == target2_build_file.file_ref.path
+          end
+        end
+        new.sort_by { |build_file| build_file.file_ref.path }
+      end
+    end
+  end
+end

data/vendor/bundle/gems/xcodeproj-1.9.0/lib/xcodeproj/plist.rb

@@ -0,0 +1,94 @@
+autoload :Nanaimo, 'nanaimo'
+autoload :CFPropertyList, 'cfpropertylist'
+
+module Xcodeproj
+  # Provides support for loading and serializing property list files.
+  #
+  module Plist
+    # @return [Hash] Returns the native objects loaded from a property list
+    #         file.
+    #
+    # @param  [#to_s] path
+    #         The path of the file.
+    #
+    def self.read_from_path(path)
+      path = path.to_s
+      unless File.exist?(path)
+        raise Informative, "The plist file at path `#{path}` doesn't exist."
+      end
+      contents = File.read(path)
+      if file_in_conflict?(contents)
+        raise Informative, "The file `#{path}` is in a merge conflict."
+      end
+      case Nanaimo::Reader.plist_type(contents)
+      when :xml, :binary
+        CFPropertyList.native_types(CFPropertyList::List.new(:data => contents).value)
+      else
+        Nanaimo::Reader.new(contents).parse!.as_ruby
+      end
+    end
+
+    # 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 self.write_to_path(hash, path)
+      if hash.respond_to?(:to_hash)
+        hash = hash.to_hash
+      else
+        raise TypeError, "The given `#{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.empty?
+
+      File.open(path, 'w') do |f|
+        plist = Nanaimo::Plist.new(hash, :xml)
+        Nanaimo::Writer::XMLWriter.new(plist, :pretty => true, :output => f, :strict => false).write
+      end
+    end
+
+    # The known modules that can serialize plists.
+    #
+    KNOWN_IMPLEMENTATIONS = []
+
+    class << self
+      # @deprecated This method will be removed in 2.0
+      #
+      # @return [Nil]
+      #
+      attr_accessor :implementation
+    end
+
+    # @deprecated This method will be removed in 2.0
+    #
+    # @return [Nil]
+    #
+    def self.autoload_implementation
+    end
+
+    # @return [Bool] Checks whether there are merge conflicts in the file.
+    #
+    # @param  [#to_s] contents
+    #         The contents of the file.
+    #
+    def self.file_in_conflict?(contents)
+      conflict_regex = /
+        ^<{7}(?!<) # Exactly 7 left arrows at the beginning of the line
+        [\w\W]* # Anything
+        ^={7}(?!=) # Exactly 7 equality symbols at the beginning of the line
+        [\w\W]* # Anything
+        ^>{7}(?!>) # Exactly 7 right arrows at the beginning of the line
+      /xm
+      contents.match(conflict_regex)
+    end
+  end
+end

data/vendor/bundle/gems/xcodeproj-1.9.0/lib/xcodeproj/project.rb

@@ -0,0 +1,867 @@
+require 'atomos'
+require 'fileutils'
+require 'securerandom'
+
+require 'xcodeproj/project/object'
+require 'xcodeproj/project/project_helper'
+require 'xcodeproj/project/uuid_generator'
+require 'xcodeproj/plist'
+
+module Xcodeproj
+  # This class represents a Xcode project document.
+  #
+  # It can be used to manipulate existing documents or even create new ones
+  # from scratch.
+  #
+  # An Xcode project document is a plist file where the root is a dictionary
+  # containing the following keys:
+  #
+  # - archiveVersion: the version of the document.
+  # - objectVersion: the version of the objects description.
+  # - classes: a key that apparently is always empty.
+  # - objects: a dictionary where the UUID of every object is associated to
+  #   its attributes.
+  # - rootObject: the UUID identifier of the root object ({PBXProject}).
+  #
+  # Every object is in turn a dictionary that specifies an `isa` (the class of
+  # the object) and in accordance to it maintains a set attributes. Those
+  # attributes might reference one or more other objects by UUID. If the
+  # reference is a collection, it is ordered.
+  #
+  # The {Project} API returns instances of {AbstractObject} which wrap the
+  # objects described in the Xcode project document. All the attributes types
+  # are preserved from the plist, except for the relationships which are
+  # replaced with objects instead of UUIDs.
+  #
+  # An object might be referenced by multiple objects, an when no other object
+  # is references it, it becomes unreachable (the root object is referenced by
+  # the project itself). Xcodeproj takes care of adding and removing those
+  # objects from the `objects` dictionary so the project is always in a
+  # consistent state.
+  #
+  class Project
+    include Object
+
+    # @return [Pathname] the path of the project.
+    #
+    attr_reader :path
+
+    # @return [Pathname] the directory of the project
+    #
+    attr_reader :project_dir
+
+    # @param  [Pathname, String] path @see path
+    #         The path provided will be expanded to an absolute path.
+    # @param  [Bool] skip_initialization
+    #         Wether the project should be initialized from scratch.
+    # @param  [Int] object_version
+    #         Object version to use for serialization, defaults to Xcode 3.2 compatible.
+    #
+    # @example Creating a project
+    #         Project.new("path/to/Project.xcodeproj")
+    #
+    # @note When initializing the project, Xcodeproj mimics the Xcode behaviour
+    #       including the setup of a debug and release configuration. If you want a
+    #       clean project without any configurations, you should override the
+    #       `initialize_from_scratch` method to not add these configurations and
+    #       manually set the object version.
+    #
+    def initialize(path, skip_initialization = false, object_version = Constants::DEFAULT_OBJECT_VERSION)
+      @path = Pathname.new(path).expand_path
+      @project_dir = @path.dirname
+      @objects_by_uuid = {}
+      @generated_uuids = []
+      @available_uuids = []
+      @dirty           = true
+      unless skip_initialization.is_a?(TrueClass) || skip_initialization.is_a?(FalseClass)
+        raise ArgumentError, '[Xcodeproj] Initialization parameter expected to ' \
+          "be a boolean #{skip_initialization}"
+      end
+      unless skip_initialization
+        initialize_from_scratch
+        @object_version = object_version.to_s
+        unless Constants::COMPATIBILITY_VERSION_BY_OBJECT_VERSION.key?(object_version)
+          raise ArgumentError, "[Xcodeproj] Unable to find compatibility version string for object version `#{object_version}`."
+        end
+        root_object.compatibility_version = Constants::COMPATIBILITY_VERSION_BY_OBJECT_VERSION[object_version]
+      end
+    end
+
+    # Opens the project at the given path.
+    #
+    # @param  [Pathname, String] path
+    #         The path to the Xcode project document (xcodeproj).
+    #
+    # @raise  If the project versions are more recent than the ones know to
+    #         Xcodeproj to prevent it from corrupting existing projects.
+    #         Naturally, this would never happen with a project generated by
+    #         xcodeproj itself.
+    #
+    # @raise  If it can't find the root object. This means that the project is
+    #         malformed.
+    #
+    # @example Opening a project
+    #         Project.open("path/to/Project.xcodeproj")
+    #
+    def self.open(path)
+      path = Pathname.pwd + path
+      unless Pathname.new(path).exist?
+        raise "[Xcodeproj] Unable to open `#{path}` because it doesn't exist."
+      end
+      project = new(path, true)
+      project.send(:initialize_from_file)
+      project
+    end
+
+    # @return [String] the archive version.
+    #
+    attr_reader :archive_version
+
+    # @return [Hash] an dictionary whose purpose is unknown.
+    #
+    attr_reader :classes
+
+    # @return [String] the objects version.
+    #
+    attr_reader :object_version
+
+    # @return [Hash{String => AbstractObject}] A hash containing all the
+    #         objects of the project by UUID.
+    #
+    attr_reader :objects_by_uuid
+
+    # @return [PBXProject] the root object of the project.
+    #
+    attr_reader :root_object
+
+    # A fast way to see if two {Project} instances refer to the same projects on
+    # disk. Use this over {#eql?} when you do not need to compare the full data.
+    #
+    # This shallow comparison was chosen as the (common) `==` implementation,
+    # because it was too easy to introduce changes into the Xcodeproj code-base
+    # that were slower than O(1).
+    #
+    # @return [Boolean] whether or not the two `Project` instances refer to the
+    #         same projects on disk, determined solely by {#path} and
+    #         `root_object.uuid` equality.
+    #
+    # @todo If ever needed, we could also compare `uuids.sort` instead.
+    #
+    def ==(other)
+      other && path == other.path && root_object.uuid == other.root_object.uuid
+    end
+
+    # Compares the project to another one, or to a plist representation.
+    #
+    # @note This operation can be extremely expensive, because it converts a
+    #       `Project` instance to a hash, and should _only_ ever be used to
+    #       determine wether or not the data contents of two `Project` instances
+    #       are completely equal.
+    #
+    #       To simply determine wether or not two {Project} instances refer to
+    #       the same projects on disk, use the {#==} method instead.
+    #
+    # @param  [#to_hash] other the object to compare.
+    #
+    # @return [Boolean] whether the project is equivalent to the given object.
+    #
+    def eql?(other)
+      other.respond_to?(:to_hash) && to_hash == other.to_hash
+    end
+
+    def to_s
+      "#<#{self.class}> path:`#{path}` UUID:`#{root_object.uuid}`"
+    end
+
+    alias_method :inspect, :to_s
+
+    public
+
+    # @!group Initialization
+    #-------------------------------------------------------------------------#
+
+    # Initializes the instance from scratch.
+    #
+    def initialize_from_scratch
+      @archive_version =  Constants::LAST_KNOWN_ARCHIVE_VERSION.to_s
+      @classes         =  {}
+
+      root_object.remove_referrer(self) if root_object
+      @root_object = new(PBXProject)
+      root_object.add_referrer(self)
+
+      root_object.main_group = new(PBXGroup)
+      root_object.product_ref_group = root_object.main_group.new_group('Products')
+
+      config_list = new(XCConfigurationList)
+      root_object.build_configuration_list = config_list
+      config_list.default_configuration_name = 'Release'
+      config_list.default_configuration_is_visible = '0'
+      add_build_configuration('Debug', :debug)
+      add_build_configuration('Release', :release)
+
+      new_group('Frameworks')
+    end
+
+    # Initializes the instance with the project stored in the `path` attribute.
+    #
+    def initialize_from_file
+      pbxproj_path = path + 'project.pbxproj'
+      plist = Plist.read_from_path(pbxproj_path.to_s)
+      root_object.remove_referrer(self) if root_object
+      @root_object     = new_from_plist(plist['rootObject'], plist['objects'], self)
+      @archive_version = plist['archiveVersion']
+      @object_version  = plist['objectVersion']
+      @classes         = plist['classes'] || {}
+      @dirty           = false
+
+      unless root_object
+        raise "[Xcodeproj] Unable to find a root object in #{pbxproj_path}."
+      end
+
+      if archive_version.to_i > Constants::LAST_KNOWN_ARCHIVE_VERSION
+        raise '[Xcodeproj] Unknown archive version.'
+      end
+
+      if object_version.to_i > Constants::LAST_KNOWN_OBJECT_VERSION
+        raise '[Xcodeproj] Unknown object version.'
+      end
+
+      # Projects can have product_ref_groups that are not listed in the main_groups["Products"]
+      root_object.product_ref_group ||= root_object.main_group['Products'] || root_object.main_group.new_group('Products')
+    end
+
+    public
+
+    # @!group Plist serialization
+    #-------------------------------------------------------------------------#
+
+    # Creates a new object from the given UUID and `objects` hash (of a plist).
+    #
+    # The method sets up any relationship of the new object, generating the
+    # destination object(s) if not already present in the project.
+    #
+    # @note   This method is used to generate the root object
+    #         from a plist. Subsequent invocation are called by the
+    #         {AbstractObject#configure_with_plist}. Clients of {Xcodeproj} are
+    #         not expected to call this method.
+    #
+    # @param  [String] uuid
+    #         The UUID of the object that needs to be generated.
+    #
+    # @param  [Hash {String => Hash}] objects_by_uuid_plist
+    #         The `objects` hash of the plist representation of the project.
+    #
+    # @param  [Boolean] root_object
+    #         Whether the requested object is the root object and needs to be
+    #         retained by the project before configuration to add it to the
+    #         `objects` hash and avoid infinite loops.
+    #
+    # @return [AbstractObject] the new object.
+    #
+    # @visibility private.
+    #
+    def new_from_plist(uuid, objects_by_uuid_plist, root_object = false)
+      attributes = objects_by_uuid_plist[uuid]
+      if attributes
+        klass = Object.const_get(attributes['isa'])
+        object = klass.new(self, uuid)
+        objects_by_uuid[uuid] = object
+        object.add_referrer(self) if root_object
+        object.configure_with_plist(objects_by_uuid_plist)
+        object
+      end
+    end
+
+    # @return [Hash] The hash representation of the project.
+    #
+    def to_hash
+      plist = {}
+      objects_dictionary = {}
+      objects.each { |obj| objects_dictionary[obj.uuid] = obj.to_hash }
+      plist['objects']        =  objects_dictionary
+      plist['archiveVersion'] =  archive_version.to_s
+      plist['objectVersion']  =  object_version.to_s
+      plist['classes']        =  classes
+      plist['rootObject']     =  root_object.uuid
+      plist
+    end
+
+    def to_ascii_plist
+      plist = {}
+      objects_dictionary = {}
+      objects
+        .sort_by { |o| [o.isa, o.uuid] }
+        .each do |obj|
+          key = Nanaimo::String.new(obj.uuid, obj.ascii_plist_annotation)
+          value = obj.to_ascii_plist.tap { |a| a.annotation = nil }
+          objects_dictionary[key] = value
+        end
+      plist['archiveVersion'] =  archive_version.to_s
+      plist['classes']        =  classes
+      plist['objectVersion']  =  object_version.to_s
+      plist['objects']        =  objects_dictionary
+      plist['rootObject']     =  Nanaimo::String.new(root_object.uuid, root_object.ascii_plist_annotation)
+      Nanaimo::Plist.new.tap { |p| p.root_object = plist }
+    end
+
+    # Converts the objects tree to a hash substituting the hash
+    # of the referenced to their UUID reference. As a consequence the hash of
+    # an object might appear multiple times and the information about their
+    # uniqueness is lost.
+    #
+    # This method is designed to work in conjunction with {Hash#recursive_diff}
+    # to provide a complete, yet readable, diff of two projects *not* affected
+    # by differences in UUIDs.
+    #
+    # @return [Hash] a hash representation of the project different from the
+    #         plist one.
+    #
+    def to_tree_hash
+      hash = {}
+      objects_dictionary = {}
+      hash['objects']        =  objects_dictionary
+      hash['archiveVersion'] =  archive_version.to_s
+      hash['objectVersion']  =  object_version.to_s
+      hash['classes']        =  classes
+      hash['rootObject']     =  root_object.to_tree_hash
+      hash
+    end
+
+    # @return [Hash{String => Hash}] A hash suitable to display the project
+    #         to the user.
+    #
+    def pretty_print
+      build_configurations = root_object.build_configuration_list.build_configurations
+      {
+        'File References' => root_object.main_group.pretty_print.values.first,
+        'Targets' => root_object.targets.map(&:pretty_print),
+        'Build Configurations' => build_configurations.sort_by(&:name).map(&:pretty_print),
+      }
+    end
+
+    # Serializes the project in the xcodeproj format using the path provided
+    # during initialization or the given path (`xcodeproj` file). If a path is
+    # provided file references depending on the root of the project are not
+    # updated automatically, thus clients are responsible to perform any needed
+    # modification before saving.
+    #
+    # @param  [String, Pathname] path
+    #         The optional path where the project should be saved.
+    #
+    # @example Saving a project
+    #   project.save
+    #   project.save
+    #
+    # @return [void]
+    #
+    def save(save_path = nil)
+      save_path ||= path
+      @dirty = false if save_path == path
+      FileUtils.mkdir_p(save_path)
+      file = File.join(save_path, 'project.pbxproj')
+      Atomos.atomic_write(file) do |f|
+        Nanaimo::Writer::PBXProjWriter.new(to_ascii_plist, :pretty => true, :output => f, :strict => false).write
+      end
+    end
+
+    # Marks the project as dirty, that is, modified from what is on disk.
+    #
+    # @return [void]
+    #
+    def mark_dirty!
+      @dirty = true
+    end
+
+    # @return [Boolean] Whether this project has been modified since read from
+    #         disk or saved.
+    #
+    def dirty?
+      @dirty == true
+    end
+
+    # Replaces all the UUIDs in the project with deterministic MD5 checksums.
+    #
+    # @note The current sorting of the project is taken into account when
+    #       generating the new UUIDs.
+    #
+    # @note This method should only be used for entirely machine-generated
+    #       projects, as true UUIDs are useful for tracking changes in the
+    #       project.
+    #
+    # @return [void]
+    #
+    def predictabilize_uuids
+      UUIDGenerator.new([self]).generate!
+    end
+
+    # Replaces all the UUIDs in the list of provided projects with deterministic MD5 checksums.
+    #
+    # @param  [Array<Project>] projects
+    #
+    # @note The current sorting of the project is taken into account when
+    #       generating the new UUIDs.
+    #
+    # @note This method should only be used for entirely machine-generated
+    #       projects, as true UUIDs are useful for tracking changes in the
+    #       project.
+    #
+    # @return [void]
+    #
+    def self.predictabilize_uuids(projects)
+      UUIDGenerator.new(projects).generate!
+    end
+
+    public
+
+    # @!group Creating objects
+    #-------------------------------------------------------------------------#
+
+    # Creates a new object with a suitable UUID.
+    #
+    # The object is only configured with the default values of the `:simple`
+    # attributes, for this reason it is better to use the convenience methods
+    # offered by the {AbstractObject} subclasses or by this class.
+    #
+    # @param  [Class, String] klass
+    #         The concrete subclass of AbstractObject for new object or its
+    #         ISA.
+    #
+    # @return [AbstractObject] the new object.
+    #
+    def new(klass)
+      if klass.is_a?(String)
+        klass = Object.const_get(klass)
+      end
+      object = klass.new(self, generate_uuid)
+      object.initialize_defaults
+      object
+    end
+
+    # Generates a UUID unique for the project.
+    #
+    # @note   UUIDs are not guaranteed to be generated unique because we need
+    #         to trim the ones generated in the xcodeproj extension.
+    #
+    # @note   Implementation detail: as objects usually are created serially
+    #         this method creates a batch of UUID and stores the not colliding
+    #         ones, so the search for collisions with known UUIDS (a
+    #         performance bottleneck) is performed less often.
+    #
+    # @return [String] A UUID unique to the project.
+    #
+    def generate_uuid
+      generate_available_uuid_list while @available_uuids.empty?
+      @available_uuids.shift
+    end
+
+    # @return [Array<String>] the list of all the generated UUIDs.
+    #
+    # @note   Used for checking new UUIDs for duplicates with UUIDs already
+    #         generated but used for objects which are not yet part of the
+    #         `objects` hash but which might be added at a later time.
+    #
+    attr_reader :generated_uuids
+
+    # Pre-generates the given number of UUIDs. Useful for optimizing
+    # performance when the rough number of objects that will be created is
+    # known in advance.
+    #
+    # @param  [Integer] count
+    #         the number of UUIDs that should be generated.
+    #
+    # @note   This method might generated a minor number of uniques UUIDs than
+    #         the given count, because some might be duplicated a thus will be
+    #         discarded.
+    #
+    # @return [void]
+    #
+    def generate_available_uuid_list(count = 100)
+      new_uuids = (0..count).map { SecureRandom.hex(12).upcase }
+      uniques = (new_uuids - (@generated_uuids + uuids))
+      @generated_uuids += uniques
+      @available_uuids += uniques
+    end
+
+    public
+
+    # @!group Convenience accessors
+    #-------------------------------------------------------------------------#
+
+    # @return [Array<AbstractObject>] all the objects of the project.
+    #
+    def objects
+      objects_by_uuid.values
+    end
+
+    # @return [Array<String>] all the UUIDs of the project.
+    #
+    def uuids
+      objects_by_uuid.keys
+    end
+
+    # @return [Array<AbstractObject>] all the objects of the project with a
+    #         given ISA.
+    #
+    def list_by_class(klass)
+      objects.select { |o| o.class == klass }
+    end
+
+    # @return [PBXGroup] the main top-level group.
+    #
+    def main_group
+      root_object.main_group
+    end
+
+    # @return [ObjectList<PBXGroup>] a list of all the groups in the
+    #         project.
+    #
+    def groups
+      main_group.groups
+    end
+
+    # Returns a group at the given subpath relative to the main group.
+    #
+    # @example
+    #   frameworks = project['Frameworks']
+    #   frameworks.name #=> 'Frameworks'
+    #   main_group.children.include? frameworks #=> True
+    #
+    # @param  [String] group_path @see MobileCoreServices
+    #
+    # @return [PBXGroup] the group at the given subpath.
+    #
+    def [](group_path)
+      main_group[group_path]
+    end
+
+    # @return [ObjectList<PBXFileReference>] a list of all the files in the
+    #         project.
+    #
+    def files
+      objects.grep(PBXFileReference)
+    end
+
+    # Returns the file reference for the given absolute path.
+    #
+    # @param  [#to_s] absolute_path
+    #         The absolute path of the file whose reference is needed.
+    #
+    # @return [PBXFileReference] The file reference.
+    # @return [Nil] If no file reference could be found.
+    #
+    def reference_for_path(absolute_path)
+      absolute_pathname = Pathname.new(absolute_path)
+
+      unless absolute_pathname.absolute?
+        raise ArgumentError, "Paths must be absolute #{absolute_path}"
+      end
+
+      objects.find do |child|
+        child.isa == 'PBXFileReference' && child.real_path == absolute_pathname
+      end
+    end
+
+    # @return [ObjectList<AbstractTarget>] A list of all the targets in the
+    #         project.
+    #
+    def targets
+      root_object.targets
+    end
+
+    # @return [ObjectList<PBXNativeTarget>] A list of all the targets in the
+    #         project excluding aggregate targets.
+    #
+    def native_targets
+      root_object.targets.grep(PBXNativeTarget)
+    end
+
+    # Checks the native target for any targets in the project
+    # that are dependent on the native target and would be
+    # embedded in it at build time
+    #
+    # @param  [PBXNativeTarget] native target to check for
+    #         embedded targets
+    #
+    #
+    # @return [Array<PBXNativeTarget>] A list of all targets that
+    #         are embedded in the passed in target
+    #
+    def embedded_targets_in_native_target(native_target)
+      native_targets.select do |target|
+        host_targets_for_embedded_target(target).map(&:uuid).include? native_target.uuid
+      end
+    end
+
+    # Returns the native targets, in which the embedded target is
+    # embedded. This works by traversing the targets to find those
+    # where the target is a dependency.
+    #
+    # @param  [PBXNativeTarget] native target that might be embedded
+    #         in another target
+    #
+    # @return [Array<PBXNativeTarget>] the native targets that host the
+    #         embedded target
+    #
+    def host_targets_for_embedded_target(embedded_target)
+      native_targets.select do |native_target|
+        ((embedded_target.uuid != native_target.uuid) &&
+         (native_target.dependencies.map(&:native_target_uuid).include? embedded_target.uuid))
+      end
+    end
+
+    # @return [PBXGroup] The group which holds the product file references.
+    #
+    def products_group
+      root_object.product_ref_group
+    end
+
+    # @return [ObjectList<PBXFileReference>] A list of the product file
+    #         references.
+    #
+    def products
+      products_group.children
+    end
+
+    # @return [PBXGroup] the `Frameworks` group creating it if necessary.
+    #
+    def frameworks_group
+      main_group['Frameworks'] || main_group.new_group('Frameworks')
+    end
+
+    # @return [ObjectList<XCConfigurationList>] The build configuration list of
+    #         the project.
+    #
+    def build_configuration_list
+      root_object.build_configuration_list
+    end
+
+    # @return [ObjectList<XCBuildConfiguration>] A list of project wide
+    #         build configurations.
+    #
+    def build_configurations
+      root_object.build_configuration_list.build_configurations
+    end
+
+    # Returns the build settings of the project wide build configuration with
+    # the given name.
+    #
+    # @param  [String] name
+    #         The name of a project wide build configuration.
+    #
+    # @return [Hash] The build settings.
+    #
+    def build_settings(name)
+      root_object.build_configuration_list.build_settings(name)
+    end
+
+    public
+
+    # @!group Helpers
+    #-------------------------------------------------------------------------#
+
+    # Creates a new file reference in the main group.
+    #
+    # @param  @see PBXGroup#new_file
+    #
+    # @return [PBXFileReference] the new file.
+    #
+    def new_file(path, source_tree = :group)
+      main_group.new_file(path, source_tree)
+    end
+
+    # Creates a new group at the given subpath of the main group.
+    #
+    # @param  @see PBXGroup#new_group
+    #
+    # @return [PBXGroup] the new group.
+    #
+    def new_group(name, path = nil, source_tree = :group)
+      main_group.new_group(name, path, source_tree)
+    end
+
+    # Creates a new target and adds it to the project.
+    #
+    # The target is configured for the given platform and its file reference it
+    # is added to the {products_group}.
+    #
+    # The target is pre-populated with common build settings, and the
+    # appropriate Framework according to the platform is added to to its
+    # Frameworks phase.
+    #
+    # @param  [Symbol] type
+    #         the type of target. Can be `:application`, `:framework`,
+    #         `:dynamic_library` or `:static_library`.
+    #
+    # @param  [String] name
+    #         the name of the target product.
+    #
+    # @param  [Symbol] platform
+    #         the platform of the target. Can be `:ios` or `:osx`.
+    #
+    # @param  [String] deployment_target
+    #         the deployment target for the platform.
+    #
+    # @param  [PBXGroup] product_group
+    #         the product group, where to add to a file reference of the
+    #         created target.
+    #
+    # @param  [Symbol] language
+    #         the primary language of the target, can be `:objc` or `:swift`.
+    #
+    # @return [PBXNativeTarget] the target.
+    #
+    def new_target(type, name, platform, deployment_target = nil, product_group = nil, language = nil)
+      product_group ||= products_group
+      ProjectHelper.new_target(self, type, name, platform, deployment_target, product_group, language)
+    end
+
+    # Creates a new resource bundles target and adds it to the project.
+    #
+    # The target is configured for the given platform and its file reference it
+    # is added to the {products_group}.
+    #
+    # The target is pre-populated with common build settings
+    #
+    # @param  [String] name
+    #         the name of the resources bundle.
+    #
+    # @param  [Symbol] platform
+    #         the platform of the resources bundle. Can be `:ios` or `:osx`.
+    #
+    # @return [PBXNativeTarget] the target.
+    #
+    def new_resources_bundle(name, platform, product_group = nil)
+      product_group ||= products_group
+      ProjectHelper.new_resources_bundle(self, name, platform, product_group)
+    end
+
+    # Creates a new target and adds it to the project.
+    #
+    # The target is configured for the given platform and its file reference it
+    # is added to the {products_group}.
+    #
+    # The target is pre-populated with common build settings, and the
+    # appropriate Framework according to the platform is added to to its
+    # Frameworks phase.
+    #
+    # @param  [String] name
+    #         the name of the target.
+    #
+    # @param  [Array<AbstractTarget>] target_dependencies
+    #         targets, which should be added as dependencies.
+    #
+    # @param  [Symbol] platform
+    #         the platform of the aggregate target. Can be `:ios` or `:osx`.
+    #
+    # @param  [String] deployment_target
+    #         the deployment target for the platform.
+    #
+    # @return [PBXNativeTarget] the target.
+    #
+    def new_aggregate_target(name, target_dependencies = [], platform = nil, deployment_target = nil)
+      ProjectHelper.new_aggregate_target(self, name, platform, deployment_target).tap do |aggregate_target|
+        target_dependencies.each do |dep|
+          aggregate_target.add_dependency(dep)
+        end
+      end
+    end
+
+    # Adds a new build configuration to the project and populates its with
+    # default settings according to the provided type.
+    #
+    # @param  [String] name
+    #         The name of the build configuration.
+    #
+    # @param  [Symbol] type
+    #         The type of the build configuration used to populate the build
+    #         settings, must be :debug or :release.
+    #
+    # @return [XCBuildConfiguration] The new build configuration.
+    #
+    def add_build_configuration(name, type)
+      build_configuration_list = root_object.build_configuration_list
+      if build_configuration = build_configuration_list[name]
+        build_configuration
+      else
+        build_configuration = new(XCBuildConfiguration)
+        build_configuration.name = name
+        common_settings = Constants::PROJECT_DEFAULT_BUILD_SETTINGS
+        settings = ProjectHelper.deep_dup(common_settings[:all])
+        settings.merge!(ProjectHelper.deep_dup(common_settings[type]))
+        build_configuration.build_settings = settings
+        build_configuration_list.build_configurations << build_configuration
+        build_configuration
+      end
+    end
+
+    # Sorts the project.
+    #
+    # @param  [Hash] options
+    #         the sorting options.
+    # @option options [Symbol] :groups_position
+    #         the position of the groups can be either `:above` or `:below`.
+    #
+    # @return [void]
+    #
+    def sort(options = nil)
+      root_object.sort_recursively(options)
+    end
+
+    public
+
+    # @!group Schemes
+    #-------------------------------------------------------------------------#
+
+    # Get list of shared schemes in project
+    #
+    # @param [String] path
+    #         project path
+    #
+    # @return [Array]
+    #
+    def self.schemes(project_path)
+      schemes = Dir[File.join(project_path, 'xcshareddata', 'xcschemes', '*.xcscheme')].map do |scheme|
+        File.basename(scheme, '.xcscheme')
+      end
+      schemes << File.basename(project_path, '.xcodeproj') if schemes.empty?
+      schemes
+    end
+
+    # Recreates the user schemes of the project from scratch (removes the
+    # folder) and optionally hides them.
+    #
+    # @param  [Bool] visible
+    #         Whether the schemes should be visible or hidden.
+    #
+    # @return [void]
+    #
+    def recreate_user_schemes(visible = true)
+      schemes_dir = XCScheme.user_data_dir(path)
+      FileUtils.rm_rf(schemes_dir)
+      FileUtils.mkdir_p(schemes_dir)
+
+      xcschememanagement = {}
+      xcschememanagement['SchemeUserState'] = {}
+      xcschememanagement['SuppressBuildableAutocreation'] = {}
+
+      targets.each do |target|
+        scheme = XCScheme.new
+
+        test_target = target if target.respond_to?(:test_target_type?) && target.test_target_type?
+        launch_target = target.respond_to?(:launchable_target_type?) && target.launchable_target_type?
+        scheme.configure_with_targets(target, test_target, :launch_target => launch_target)
+
+        yield scheme, target if block_given?
+        scheme.save_as(path, target.name, false)
+        xcschememanagement['SchemeUserState']["#{target.name}.xcscheme"] = {}
+        xcschememanagement['SchemeUserState']["#{target.name}.xcscheme"]['isShown'] = visible
+      end
+
+      xcschememanagement_path = schemes_dir + 'xcschememanagement.plist'
+      Plist.write_to_path(xcschememanagement, xcschememanagement_path)
+    end
+
+    #-------------------------------------------------------------------------#
+  end
+end