xcodeproj 0.1.0 → 0.2.0.rc1

data/lib/xcodeproj/project/association.rb

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

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

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

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

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

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

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

data/lib/xcodeproj/project/object.rb

@@ -0,0 +1,207 @@
+require 'xcodeproj/inflector'
+
+module Xcodeproj
+  class Project
+    # This is the namespace in which all the classes that wrap the objects in
+    # a Xcode project reside.
+    #
+    # The base class from which all classes inherit is AbstractPBXObject.
+    #
+    # If you need to deal with these classes directly, it's possible to include
+    # this namespace into yours, making it unnecessary to prefix them with
+    # Xcodeproj::Project::Object.
+    #
+    # @example
+    #
+    #     class SourceFileSorter
+    #       include Xcodeproj::Project::Object
+    #     end
+    module Object
+
+      # Missing constants that begin with either `PBX' or `XC' are assumed to
+      # be valid classes in a Xcode project. A new AbstractPBXObject subclass is
+      # created for the constant and returned.
+      #
+      # @return [Class]  The generated class inhertiting from AbstractPBXObject.
+      def self.const_missing(name)
+        if name.to_s =~ /^(PBX|XC)/
+          klass = Class.new(AbstractPBXObject)
+          const_set(name, klass)
+          klass
+        else
+          super
+        end
+      end
+
+      # This is the base class of all object types that can exist in a Xcode
+      # project. As such it provides common behavior, but you can only use
+      # instances of subclasses of AbstractPBXObject, because this class does
+      # not exist in actual Xcode projects.
+      class AbstractPBXObject
+
+        # This defines accessor methods for a key-value pair which occurs in the
+        # attributes hash that the object wraps.
+        #
+        #
+        # @example
+        #
+        #     # Create getter and setter methods named after the key it corresponds to
+        #     # in the attributes hash:
+        #
+        #     class PBXBuildPhase < AbstractPBXObject
+        #       attribute :settings
+        #     end
+        #
+        #     build_phase.attributes # => { 'settings' => { 'COMPILER_FLAGS' => '-fobjc-arc' }, ... }
+        #     build_phase.settings # => { 'COMPILER_FLAGS' => '-fobjc-arc' }
+        #
+        #     build_phase.settings = { 'COMPILER_FLAGS' => '-fobjc-no-arc' }
+        #     build_phase.attributes # => { 'settings' => { 'COMPILER_FLAGS' => '-fobjc-no-arc' }, ... }
+        #
+        #     # Or with a custom getter and setter methods:
+        #
+        #     class PBXCopyFilesBuildPhase < AbstractPBXObject
+        #       attribute :dst_path, :as => :destination_path
+        #     end
+        #
+        #     build_phase.attributes # => { 'dstPath' => 'some/path', ... }
+        #     build_phase.destination_path # => 'some/path'
+        #
+        #     build_phase.destination_path = 'another/path'
+        #     build_phase.attributes # => { 'dstPath' => 'another/path', ... }
+        #
+        #
+        # @param [Symbol, String] attribute_name  The key in snake case.
+        # @option options [Symbol String] :as     An optional custom name for
+        #                                         the getter and setter methods.
+        def self.attribute(name, options = {})
+          accessor_name  = (options[:as] || name).to_s
+          attribute_name = name.to_s.camelize(:lower) # change `foo_bar' to `fooBar'
+          define_method(accessor_name) { @attributes[attribute_name] }
+          define_method("#{accessor_name}=") { |value| @attributes[attribute_name] = value }
+        end
+
+        def self.isa
+          @isa ||= name.split('::').last
+        end
+
+        attr_reader :uuid, :attributes, :project
+
+        # [String] the object's class name
+        attribute :isa
+
+        # [String] the object's name
+        attribute :name
+
+        # It is not recommended that you instantiate objects through this
+        # constructor. It is much easier to use associations to create them.
+        #
+        # @example
+        #
+        #     file_reference = project.files.new('path' => 'path/to/file')
+        #
+        # @return [AbstractPBXObject]
+        def initialize(project, uuid, attributes)
+          @project, @attributes = project, attributes
+          self.isa ||= self.class.isa
+          unless uuid
+            # Add new objects to the main hash with a unique UUID
+            uuid = generate_uuid
+            @project.add_object_hash(uuid, @attributes)
+          end
+          @uuid = uuid
+        end
+
+        def destroy
+          @project.objects_hash.delete(uuid)
+        end
+
+        def ==(other)
+          other.is_a?(AbstractPBXObject) && self.uuid == other.uuid
+        end
+
+        def <=>(other)
+          self.uuid <=> other.uuid
+        end
+
+        def inspect
+          "#<#{isa} UUID: `#{uuid}', name: `#{name}'>"
+        end
+
+        def matches_attributes?(attributes)
+          attributes.all? do |attribute, expected_value|
+            return nil unless respond_to?(attribute)
+
+            if expected_value.is_a?(Hash)
+              send(attribute).matches_attributes?(expected_value)
+            else
+              send(attribute) == expected_value
+            end
+          end
+        end
+
+        # Returns a PBXObjectList instance of objects in the `uuid_list`.
+        #
+        # By default this list will scope the list by objects matching the
+        # specified class and add objects, pushed onto the list, to the given
+        # `uuid_list` array.
+        #
+        # If a block is given the list instance is yielded so that the default
+        # callbacks can be overridden.
+        #
+        # @param  [Array] uuid_list          The UUID array instance which is
+        #                                    part of the internal data. If this
+        #                                    would be an arbitrary array and an
+        #                                    object is added, then it doesn't
+        #                                    actually modify the internal data,
+        #                                    meaning the change is lost.
+        #
+        # @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(uuid_list, klass)
+          PBXObjectList.new(klass, @project) do |list|
+            list.let(:uuid_scope) do
+              # TODO why does this not work? should be more efficient.
+              #uuid_list.select do |uuid|
+                #@project.objects_hash[uuid]['isa'] == klass.isa
+              #end
+              uuid_list.map { |uuid| @project.objects[uuid] }.select { |o| o.is_a?(klass) }.map(&:uuid)
+            end
+            list.let(:push) do |new_object|
+              # Add the uuid of a newly created object to the uuids list
+              uuid_list << new_object.uuid
+            end
+            yield list if block_given?
+          end
+        end
+
+        private
+
+        # Generate a truly unique UUID. This is to ensure that cutting up the
+        # UUID in the xcodeproj extension doesn't cause a collision.
+        def generate_uuid
+          begin
+            uuid = Xcodeproj.generate_uuid
+          end while @project.objects_hash.has_key?(uuid)
+          uuid
+        end
+      end
+
+    end
+  end
+end
+
+require 'xcodeproj/project/association'
+require 'xcodeproj/project/object_list'
+
+# Now load the rest of the classes which inherit from AbstractPBXObject.
+require 'xcodeproj/project/object/build_phase'
+require 'xcodeproj/project/object/configuration'
+require 'xcodeproj/project/object/file_reference'
+require 'xcodeproj/project/object/group'
+require 'xcodeproj/project/object/native_target'

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

@@ -0,0 +1,89 @@
+module Xcodeproj
+  class Project
+    module Object
+
+      class PBXBuildFile < AbstractPBXObject
+        # [Hash] the list of build settings for this file
+        attribute :settings
+
+        has_one :file, :uuid => :file_ref
+      end
+
+      class PBXBuildPhase < AbstractPBXObject
+        has_many :build_files, :uuids => :files, :uuids_as => :build_file_references
+
+        # [String] some kind of magic number which seems to always be '2147483647'
+        attribute :build_action_mask
+
+        # [String] wether or not this should only be processed before deployment
+        #          (I guess). This cane be either '0', or '1'
+        attribute :run_only_for_deployment_postprocessing
+
+        def initialize(*)
+          super
+          self.build_file_references ||= []
+          # These are always the same, no idea what they are.
+          self.build_action_mask ||= "2147483647"
+          self.run_only_for_deployment_postprocessing ||= "0"
+        end
+
+        def files
+          PBXObjectList.new(PBXFileReference, @project) do |list|
+            list.let(:uuid_scope) { self.build_files.map(&:file_ref) }
+            list.let(:push) do |file|
+              self.build_files << file.build_files.new
+            end
+          end
+        end
+
+        def <<(file)
+          files << file
+        end
+      end
+
+      class PBXCopyFilesBuildPhase < PBXBuildPhase
+        # [String] the path where this file should be copied to
+        attribute :dst_path
+
+        # [String] a magic number which always seems to be "16"
+        attribute :dst_subfolder_spec
+
+        def initialize(*)
+          super
+          self.dst_path ||= '$(PRODUCT_NAME)'
+          self.dst_subfolder_spec ||= "16"
+        end
+      end
+
+      class PBXSourcesBuildPhase < PBXBuildPhase;     end
+      class PBXFrameworksBuildPhase < PBXBuildPhase;  end
+
+      # @todo Should `files`, `input_paths`, and `output_paths` be has_many
+      #       associations with file references?
+      class PBXShellScriptBuildPhase < PBXBuildPhase
+        attribute :name
+
+        attribute :files
+        attribute :input_paths
+        attribute :output_paths
+
+        # [String] The path to the script interpreter. Defaults to `/bin/sh`.
+        attribute :shell_path
+
+        # [String] The actual script to perform.
+        attribute :shell_script
+
+        def initialize(*)
+          super
+          self.files        ||= []
+          self.input_paths  ||= []
+          self.output_paths ||= []
+
+          self.shell_path   ||= '/bin/sh'
+          self.shell_script ||= ''
+        end
+      end
+
+    end
+  end
+end