xcodeproj 0.1.0 → 0.2.0.rc1

data/lib/xcodeproj/project/object/configuration.rb

@@ -0,0 +1,100 @@
+module Xcodeproj
+  class Project
+    module Object
+
+      class XCBuildConfiguration < AbstractPBXObject
+        COMMON_BUILD_SETTINGS = {
+          :all => {
+            'GCC_VERSION'                       => 'com.apple.compilers.llvm.clang.1_0',
+            'GCC_PRECOMPILE_PREFIX_HEADER'      => 'YES',
+            'PRODUCT_NAME'                      => '$(TARGET_NAME)',
+            'SKIP_INSTALL'                      => 'YES',
+            'DSTROOT'                           => '/tmp/xcodeproj.dst',
+            'ALWAYS_SEARCH_USER_PATHS'          => 'NO',
+            'GCC_C_LANGUAGE_STANDARD'           => 'gnu99',
+            'INSTALL_PATH'                      => "$(BUILT_PRODUCTS_DIR)",
+            'GCC_WARN_ABOUT_MISSING_PROTOTYPES' => 'YES',
+            'GCC_WARN_ABOUT_RETURN_TYPE'        => 'YES',
+            'GCC_WARN_UNUSED_VARIABLE'          => 'YES',
+            'OTHER_LDFLAGS'                     => '',
+            'COPY_PHASE_STRIP'                  => 'YES',
+          }.freeze,
+          :debug => {
+            'GCC_DYNAMIC_NO_PIC'                => 'NO',
+            'GCC_PREPROCESSOR_DEFINITIONS'      => ["DEBUG=1", "$(inherited)"],
+            'GCC_SYMBOLS_PRIVATE_EXTERN'        => 'NO',
+            'GCC_OPTIMIZATION_LEVEL'            => '0',
+            'COPY_PHASE_STRIP'                  => 'NO',
+          }.freeze,
+          :ios => {
+            'ARCHS'                             => "$(ARCHS_STANDARD_32_BIT)",
+            'IPHONEOS_DEPLOYMENT_TARGET'        => '4.3',
+            'PUBLIC_HEADERS_FOLDER_PATH'        => "$(TARGET_NAME)",
+            'SDKROOT'                           => 'iphoneos',
+          }.freeze,
+          :osx => {
+            'ARCHS'                             => "$(ARCHS_STANDARD_64_BIT)",
+            'GCC_ENABLE_OBJC_EXCEPTIONS'        => 'YES',
+            'GCC_WARN_64_TO_32_BIT_CONVERSION'  => 'YES',
+            'GCC_VERSION'                       => 'com.apple.compilers.llvm.clang.1_0',
+            'MACOSX_DEPLOYMENT_TARGET'          => '10.7',
+            'SDKROOT'                           => 'macosx',
+          }.freeze,
+          [:osx, :debug] => {
+            'ONLY_ACTIVE_ARCH'                  => 'YES',
+          }.freeze,
+          [:osx, :release] => {
+            'DEBUG_INFORMATION_FORMAT'          => 'dwarf-with-dsym',
+          }.freeze,
+          [:ios, :release] => {
+            'VALIDATE_PRODUCT'                  => 'YES',
+          }.freeze,
+        }.freeze
+
+        def self.new_release(project)
+          new(project, nil,
+            'name' => 'Release',
+            'buildSettings' => COMMON_BUILD_SETTINGS[:all].dup
+          )
+        end
+
+        def self.new_debug(project)
+          new(project, nil,
+            'name' => 'Debug',
+            'buildSettings' => COMMON_BUILD_SETTINGS[:all].merge(COMMON_BUILD_SETTINGS[:debug])
+          )
+        end
+
+        # [Hash] the build settings used when building a target
+        attribute :build_settings
+
+        # TODO why do I need to specify the uuid here?
+        has_one :base_configuration, :uuid => :base_configuration_reference
+
+        def initialize(*)
+          super
+          self.build_settings ||= {}
+        end
+      end
+
+      class XCConfigurationList < AbstractPBXObject
+        attribute :default_configuration_is_visible
+        attribute :default_configuration_name
+
+        has_many :build_configurations
+
+        def initialize(*)
+          super
+          self.build_configuration_references ||= []
+        end
+
+        def build_settings(build_configuration_name)
+          if config = build_configurations.where(:name => build_configuration_name)
+            config.build_settings
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/xcodeproj/project/object/file_reference.rb

@@ -0,0 +1,71 @@
+require 'xcodeproj/project/object/group'
+
+module Xcodeproj
+  class Project
+    module Object
+
+      # @todo Add a list of all possible file types for `explicit_file_type`
+      #       and `last_known_file_type`.
+      class PBXFileReference < AbstractGroupEntry
+        # [String] the path to the file relative to the source tree
+        attribute :path
+
+        # [String] the source tree to which the file is relative. It can be one
+        #          of `SOURCE_ROOT` or `SDKROOT`
+        attribute :source_tree
+
+        # [String] the file type regardless of what Xcode might think it is
+        attribute :explicit_file_type
+
+        # [String] the file type guessed by Xcode
+        attribute :last_known_file_type
+
+        # [String] wether of not this file should be indexed. This can be
+        #          either "0" or "1".
+        attribute :include_in_index
+
+        has_many :build_files, :inverse_of => :file
+
+        def self.new_static_library(project, product_name)
+          new(project, nil,
+            "includeInIndex" => "0",
+            "sourceTree" => "BUILT_PRODUCTS_DIR",
+            "path" => "lib#{product_name}.a"
+          )
+        end
+
+        def initialize(*)
+          super
+          self.path = path if path # sets default name
+          self.source_tree ||= 'SOURCE_ROOT'
+          self.include_in_index ||= "1"
+          set_default_file_type!
+        end
+
+        alias_method :_path=, :path=
+        def path=(path)
+          self._path = path
+          self.name ||= pathname.basename.to_s
+          path
+        end
+
+        def pathname
+          Pathname.new(path)
+        end
+
+        def set_default_file_type!
+          return if explicit_file_type || last_known_file_type
+          case path
+          when /\.a$/
+            self.explicit_file_type = 'archive.ar'
+          when /\.framework$/
+            self.last_known_file_type = 'wrapper.framework'
+          when /\.xcconfig$/
+            self.last_known_file_type = 'text.xcconfig'
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/xcodeproj/project/object/group.rb

@@ -0,0 +1,102 @@
+module Xcodeproj
+  class Project
+    module Object
+
+      class AbstractGroupEntry < AbstractPBXObject
+        has_one :group, :inverse_of => :children
+
+        def initialize(project, uuid, attributes)
+          is_new = uuid.nil?
+          super
+          # If there's no root_object yet, then this is probably the main group.
+          if is_new && @project.root_object
+            @project.main_group.children << self
+          end
+        end
+
+        def destroy
+          group.child_references.delete(uuid)
+          super
+        end
+
+        # Sorts groups before files and inside those sorts by name.
+        def <=>(other)
+          if self.is_a?(PBXGroup) && other.is_a?(PBXFileReference)
+            -1
+          elsif self.is_a?(PBXFileReference) && other.is_a?(PBXGroup)
+            1
+          else
+            self.name <=> other.name
+          end
+        end
+      end
+
+      # @todo The `source_tree` can probably be more than just `<group>`.
+      class PBXGroup < AbstractGroupEntry
+        # [String] the source tree to which this group is relative. It can be
+        #          `<group>`.
+        attribute :source_tree
+
+        has_many :children, :class => AbstractGroupEntry do |child|
+          # Associating the AbstractGroupEntry instance to this group through
+          # the inverse association will also remove it from the group it was
+          # in.
+          child.group = self
+        end
+
+        def initialize(*)
+          super
+          self.source_tree ||= '<group>'
+          self.child_references ||= []
+        end
+
+        def main_group?
+          @project.main_group.uuid == uuid
+        end
+
+        def name
+          if name = super
+            name
+          elsif attributes.has_key?('path')
+            File.basename(attributes['path'])
+          elsif main_group?
+            'Main Group'
+          end
+        end
+
+        def files
+          children.list_by_class(PBXFileReference)
+        end
+
+        def create_file(path)
+          files.new("path" => path)
+        end
+
+        def create_files(paths)
+          paths.map { |path| create_file(path) }
+        end
+
+        def source_files
+          children.list_by_class(PBXFileReference) do |list|
+            list.let(:uuid_scope) do
+              files.reject { |file| file.build_files.empty? }.map(&:uuid)
+            end
+          end
+        end
+
+        def groups
+          children.list_by_class(PBXGroup)
+        end
+
+        def create_group(name)
+          groups.new("name" => name)
+        end
+
+        def <<(child)
+          children << child
+        end
+      end
+
+    end
+  end
+end

data/lib/xcodeproj/project/object/native_target.rb

@@ -0,0 +1,126 @@
+module Xcodeproj
+  class Project
+    module Object
+
+      class PBXNativeTarget < AbstractPBXObject
+        STATIC_LIBRARY = 'com.apple.product-type.library.static'
+
+        # [String] the name of the build product
+        attribute :product_name
+
+        # [String] the build product type identifier
+        attribute :product_type
+
+        has_many :build_phases
+        has_many :dependencies # TODO :class => ?
+        has_many :build_rules # TODO :class => ?
+        has_one :build_configuration_list, :class => XCConfigurationList
+        has_one :product, :uuid => :product_reference
+
+        def self.new_static_library(project, platform, name)
+          project.add_system_framework(platform == :ios ? 'Foundation' : 'Cocoa')
+
+          target = new(project, nil, 'productType' => STATIC_LIBRARY, 'productName' => name)
+          target.product.path = "lib#{name}.a"
+
+          target.build_configurations.each do |config|
+            config.build_settings.merge!(XCBuildConfiguration::COMMON_BUILD_SETTINGS[platform])
+
+            # E.g. [:ios, :release]
+            extra_settings_key = [platform, config.name.downcase.to_sym]
+            if extra_settings = XCBuildConfiguration::COMMON_BUILD_SETTINGS[extra_settings_key]
+              config.build_settings.merge!(extra_settings)
+            end
+          end
+
+          target
+        end
+
+        # You need to specify a product. For a static library you can use
+        # PBXFileReference.new_static_library.
+        def initialize(project, *)
+          super
+          self.name ||= product_name
+          self.build_rule_references  ||= []
+          self.dependency_references  ||= []
+
+          unless build_phase_references
+            self.build_phase_references = []
+
+            source_build_phases.new
+            copy_files_build_phases.new
+            #shell_script_build_phases.new
+
+            phase = frameworks_build_phases.new
+            if frameworks_group = @project.groups.where(:name => 'Frameworks')
+              frameworks_group.files.each { |framework| phase << framework }
+            end
+          end
+
+          unless build_configuration_list
+            self.build_configuration_list = project.objects.add(XCConfigurationList, {
+              'defaultConfigurationIsVisible' => '0',
+              'defaultConfigurationName' => 'Release',
+            })
+            # TODO or should this happen in buildConfigurationList?
+            build_configuration_list.build_configurations.new_debug
+            build_configuration_list.build_configurations.new_release
+          end
+
+          unless product
+            self.product = @project.files.new_static_library(product_name)
+          end
+        end
+
+        alias_method :_product=, :product=
+        def product=(product)
+          self._product = product
+          @project.products << product
+        end
+
+        def build_configurations
+          build_configuration_list.build_configurations
+        end
+
+        def build_settings(build_configuration_name)
+          build_configuration_list.build_settings(build_configuration_name)
+        end
+
+        def source_build_phases
+          build_phases.list_by_class(PBXSourcesBuildPhase)
+        end
+
+        def copy_files_build_phases
+          build_phases.list_by_class(PBXCopyFilesBuildPhase)
+        end
+
+        def frameworks_build_phases
+          build_phases.list_by_class(PBXFrameworksBuildPhase)
+        end
+
+        def shell_script_build_phases
+          build_phases.list_by_class(PBXShellScriptBuildPhase)
+        end
+
+        # Finds an existing file reference or creates a new one.
+        def add_source_file(path, copy_header_phase = nil, compiler_flags = nil)
+          file = @project.files.find { |file| file.path == path.to_s } || @project.files.new('path' => path.to_s)
+          build_file = file.build_files.new
+          if path.extname == '.h'
+            build_file.settings = { 'ATTRIBUTES' => ["Public"] }
+            # Working around a bug in Xcode 4.2 betas, remove this once the Xcode bug is fixed:
+            # https://github.com/alloy/cocoapods/issues/13
+            #phase = copy_header_phase || headers_build_phases.first
+            phase = copy_header_phase || copy_files_build_phases.first
+            phase.build_files << build_file
+          else
+            build_file.settings = { 'COMPILER_FLAGS' => compiler_flags } if compiler_flags
+            source_build_phases.first.build_files << build_file
+          end
+          file
+        end
+      end
+
+    end
+  end
+end

data/lib/xcodeproj/project/object_list.rb

@@ -0,0 +1,146 @@
+module Xcodeproj
+  class Project
+
+    # In case `scoped` is an Array the list's order is maintained.
+    class PBXObjectList
+      include Enumerable
+
+      def initialize(represented_class, project)
+        @represented_class = represented_class
+        @project           = project
+        @callbacks         = {}
+
+        yield self if block_given?
+      end
+
+      # Specify callbacks for:
+      # * :uuid_scope  Returns the list of UUIDs to scope this list to.
+      # * :push        When an object is added to the list.
+      def let(callback_name, &block)
+        raise ArgumentError, "Incorrect callback `#{callback_name}'." unless [:uuid_scope, :push].include?(callback_name)
+        @callbacks[callback_name] = block
+      end
+
+      def uuid_scope
+        @callbacks[:uuid_scope].call
+      end
+
+      def empty?
+        uuid_scope.empty?
+      end
+
+      def [](uuid)
+        if uuid_scope.include?(uuid) && hash = @project.objects_hash[uuid]
+          Object.const_get(hash['isa']).new(@project, uuid, hash)
+        end
+      end
+
+      def add(klass, hash = {})
+        object = klass.new(@project, nil, hash)
+        self << object
+        object
+      end
+
+      def new(hash = {})
+        add(@represented_class, hash)
+      end
+
+      # Run Ruby in debug mode to receive warnings about calls to :push when a
+      # list does not have a callback registered for :push.
+      def push(object)
+        if @callbacks[:push]
+          @callbacks[:push].call(object)
+        else
+          if $DEBUG
+            warn "Pushed object onto a PBXObjectList that does not have a :push callback from: #{caller.first}"
+          end
+        end
+        self
+      end
+      alias_method :<<, :push
+
+      def each
+        uuid_scope.each do |uuid|
+          yield self[uuid]
+        end
+      end
+
+      def ==(other)
+        self.to_a == other.to_a
+      end
+
+      def size
+        uuid_scope.size
+      end
+
+      # Since order can't always be guaranteed, these might need to move to an order specific subclass.
+      def first
+        to_a.first
+      end
+      def last
+        to_a.last
+      end
+
+      def inspect
+        "<PBXObjectList: #{map(&:inspect).join(', ')}>"
+      end
+
+      def where(attributes)
+        find { |o| o.matches_attributes?(attributes) }
+      end
+
+      # @todo is it really necessary to have an extra method for this?
+      def object_named(name)
+        where :name => name
+      end
+
+      # Returns a PBXObjectList instance of objects in the list.
+      #
+      # By default this list will scope the list by objects matching the
+      # specified class and add objects, pushed onto the list, to the parent
+      # list
+      #
+      # If a block is given the list instance is yielded so that the default
+      # callbacks can be overridden.
+      #
+      # @param  [AbstractPBXObject] klass  The AbstractPBXObject subclass to
+      #                                    which the list should be scoped.
+      #
+      # @yield  [PBXObjectList]            The list instance, allowing you to
+      #                                    easily override the callbacks.
+      #
+      # @return [PBXObjectList<klass>]     The list of matching objects.
+      def list_by_class(klass)
+        parent = self
+        PBXObjectList.new(klass, @project) do |list|
+          list.let(:push) do |object|
+            # Objects added to the subselection should still use the same
+            # callback as this list.
+            parent << object
+          end
+          list.let(:uuid_scope) do
+            parent.uuid_scope.select do |uuid|
+              @project.objects_hash[uuid]['isa'] == klass.isa
+            end
+          end
+          yield list if block_given?
+        end
+      end
+
+      # This only makes sense on those with a specific represented class. Not the main objects list.
+      def method_missing(name, *args, &block)
+        if @represented_class.respond_to?(name)
+          object = @represented_class.send(name, @project, *args)
+          # The callbacks are only for AbstractPBXObject instances instantiated
+          # from the class method that we forwarded the message to.
+          self << object if object.is_a?(Object::AbstractPBXObject)
+          object
+        else
+          super
+        end
+      end
+
+    end
+
+  end
+end