plasmo_xcodeproj 1.21.1

data/lib/xcodeproj/project/object_dictionary.rb

@@ -0,0 +1,210 @@
+module Xcodeproj
+  class Project
+    # This class represents relationships to other objects stored in a
+    # Dictionary.
+    #
+    # It works in conjunction with the {AbstractObject} class to ensure that
+    # the project is not serialized with unreachable objects by updating the
+    # with reference count on modifications.
+    #
+    # @note To provide full support as the other classes the dictionary should:
+    #
+    #       Give the following attribute:
+    #
+    #            has_many_references_by_keys :project_references, {
+    #              :project_ref   => PBXFileReference,
+    #              :product_group => PBXGroup
+    #            }
+    #
+    #       This should be possible:
+    #
+    #            #=> Note the API:
+    #            root_object.project_references.project_ref = file
+    #
+    #            #=> This should raise:
+    #            root_object.project_references.product_group = file
+    #
+    #       I.e. generate setters and getters from the specification hash.
+    #
+    #       Also the interface is a dirty hybrid between the
+    #       {AbstractObjectAttribute} and the {ObjectList}.
+    #
+    # @note Concerning the mutations methods it is safe to call only those
+    #       which are overridden to inform objects reference count. Ideally all
+    #       the hash methods should be covered, but this is not done yet.
+    #       Moreover it is a moving target because the methods of array
+    #       usually are implemented in C.
+    #
+    # @todo This class should use a {Hash} as a backing store instead of
+    #       inheriting from it. This would prevent the usage of methods which
+    #       don't notify the objects.
+    #
+    class ObjectDictionary < Hash
+      # @param  [Object::AbstractObjectAttribute] attribute @see #attribute
+      # @param  [Object] owner @see #owner
+      #
+      def initialize(attribute, owner)
+        @attribute = attribute
+        @owner = owner
+      end
+
+      # @return [Object::AbstractObjectAttribute] The attribute that generated
+      #         the list.
+      #
+      attr_reader :attribute
+
+      # @return [Object] The object that owns the list.
+      #
+      attr_reader :owner
+
+      # @return [Array<Symbol>] The list of the allowed keys.
+      #
+      def allowed_keys
+        attribute.classes_by_key.keys
+      end
+
+      # @return [String] A string suitable for debugging.
+      #
+      def inspect
+        "<ObjectDictionary attribute:`#{@attribute.name}` " \
+          "owner:`#{@owner.display_name}` values:#{super.inspect}>"
+      end
+
+      # @!group Notification enabled methods
+      #------------------------------------------------------------------------#
+
+      # Associates an object to the given key and updates its references count.
+      #
+      # @param  [String] key
+      #         The key.
+      #
+      # @param  [AbstractObject] object
+      #         The object to add to the dictionary.
+      #
+      # @return [AbstractObject] The given object.
+      #
+      def []=(key, object)
+        key = normalize_key(key)
+        if object
+          perform_additions_operations(object, key)
+        else
+          perform_deletion_operations(self[key])
+        end
+        super(key, object)
+      end
+
+      # Removes the given key from the dictionary and informs the object that
+      # is not longer referenced by the owner.
+      #
+      # @param  [String] key
+      #         The key.
+      #
+      def delete(key)
+        key = normalize_key(key)
+        object = self[key]
+        perform_deletion_operations(object)
+        super
+      end
+
+      # @!group AbstractObject Methods
+      #-----------------------------------------------------------------------#
+
+      # @return [Hash<String => String>] The plist representation of the
+      #         dictionary where the objects are replaced by their UUIDs.
+      #
+      def to_hash
+        result = {}
+        each do |key, obj|
+          if obj
+            plist_key = Object::CaseConverter.convert_to_plist(key, nil)
+            result[plist_key] = Nanaimo::String.new(obj.uuid, obj.ascii_plist_annotation)
+          end
+        end
+        result
+      end
+
+      def to_ascii_plist
+        to_hash
+      end
+
+      # @return [Hash<String => String>] Returns a cascade representation of
+      #         the object without UUIDs.
+      #
+      def to_tree_hash
+        result = {}
+        each do |key, obj|
+          if obj
+            plist_key = Object::CaseConverter.convert_to_plist(key, nil)
+            result[plist_key] = obj.to_tree_hash
+          end
+        end
+        result
+      end
+
+      # Removes all the references to a given object.
+      #
+      def remove_reference(object)
+        each { |key, obj| self[key] = nil if obj == object }
+      end
+
+      # Informs the objects contained in the dictionary that another object is
+      # referencing them.
+      #
+      def add_referrer(referrer)
+        values.each { |obj| obj.add_referrer(referrer) }
+      end
+
+      # Informs the objects contained in the dictionary that another object
+      # stopped referencing them.
+      #
+      def remove_referrer(referrer)
+        values.each { |obj| obj.remove_referrer(referrer) }
+      end
+
+      private
+
+      # @!group Private helpers
+      #------------------------------------------------------------------------#
+
+      # @return [Symbol] Normalizes a key to a symbol converting the camel case
+      #         format with underscores.
+      #
+      # @param  [String, Symbol] key
+      #         The key to normalize.
+      #
+      def normalize_key(key)
+        if key.is_a?(String)
+          key = Object::CaseConverter.convert_to_ruby(key)
+        end
+
+        unless allowed_keys.include?(key)
+          raise "[Xcodeproj] Unsupported key `#{key}` (allowed " \
+            "`#{allowed_keys}`) for `#{inspect}`"
+        end
+        key
+      end
+
+      # Informs an object that it was added to the dictionary. In practice it
+      # adds the owner of the list as referrer to the objects. It also
+      # validates the value.
+      #
+      # @return [void]
+      #
+      def perform_additions_operations(object, key)
+        owner.mark_project_as_dirty!
+        object.add_referrer(owner)
+        attribute.validate_value_for_key(object, key)
+      end
+
+      # Informs an object that it was removed from to the dictionary, so it can
+      # remove it from its referrers and take the appropriate actions.
+      #
+      # @return [void]
+      #
+      def perform_deletion_operations(objects)
+        owner.mark_project_as_dirty!
+        objects.remove_referrer(owner)
+      end
+    end
+  end
+end

data/lib/xcodeproj/project/object_list.rb

@@ -0,0 +1,223 @@
+module Xcodeproj
+  class Project
+    # This class represents an ordered relationship to many objects.
+    #
+    # It works in conjunction with the {AbstractObject} class to ensure that
+    # the project is not serialized with unreachable objects by updating the
+    # with reference count on modifications.
+    #
+    # @note Concerning the mutations methods it is safe to call only those
+    #       which are overridden to inform objects reference count. Ideally all
+    #       the array methods should be covered, but this is not done yet.
+    #       Moreover it is a moving target because the methods of array
+    #       usually are implemented in C
+    #
+    # @todo Cover all the mutations methods of the {Array} class.
+    #
+    class ObjectList < Array
+      # {Xcodeproj} clients are not expected to create instances of
+      # {ObjectList}, it is always initialized empty and automatically by the
+      # synthesized methods generated by {AbstractObject.has_many}.
+      #
+      def initialize(attribute, owner)
+        @attribute = attribute
+        @owner = owner
+      end
+
+      # @return [Array<Class>] the attribute that generated the list.
+      #
+      attr_reader :attribute
+
+      # @return [Array<Class>] the object that owns the list.
+      #
+      attr_reader :owner
+
+      # @return [Array<String>]
+      #   the UUIDs of all the objects referenced by this list.
+      #
+      def uuids
+        map(&:uuid)
+      end
+
+      # @return [Array<AbstractObject>]
+      #   a new array generated with the objects contained in the list.
+      #
+      def objects
+        to_a
+      end
+
+      public
+
+      # @!group Notification enabled methods
+      #------------------------------------------------------------------------#
+
+      # TODO: the overridden methods are incomplete.
+
+      # Adds an array of objects to list and updates their references count.
+      #
+      # @param [Array<AbstractObject, ObjectDictionary>] objects
+      #   an array of objects to add to the list.
+      #
+      # @return [void]
+      #
+      def +(other)
+        perform_additions_operations(other)
+        super
+      end
+
+      # Appends an object to list the and updates its references count.
+      #
+      # @param  [AbstractObject, ObjectDictionary] object
+      #         The object to add to the list.
+      #
+      # @return [void]
+      #
+      def <<(object)
+        perform_additions_operations(object)
+        super
+      end
+
+      # Adds an object to the given index of the list the and updates its
+      # references count.
+      #
+      # @param  [AbstractObject, ObjectDictionary] object
+      #         The object to add to the list.
+      #
+      # @return [void]
+      #
+      def insert(index, object)
+        perform_additions_operations(object)
+        super
+      end
+
+      # Prepends an object to the list and updates its references count.
+      #
+      # @param  [AbstractObject, ObjectDictionary] object
+      #         The object to add to the list.
+      #
+      # @return [void]
+      #
+      def unshift(object)
+        perform_additions_operations(object)
+        super
+      end
+
+      # Removes an object to list and updates its references count.
+      #
+      # @param [AbstractObject, ObjectDictionary] object
+      #   the object to delete from the list.
+      #
+      # @return [AbstractObject, ObjectDictionary, Nil] the object if found.
+      #
+      def delete(object)
+        perform_deletion_operations(object)
+        super
+      end
+
+      # Removes the object at the given index from the list and updates its
+      # references count.
+      #
+      # @param [Fixnum] from
+      #        The index of the object.
+      #
+      # @return [AbstractObject, ObjectDictionary, Nil] the object if found.
+      #
+      def delete_at(index)
+        object = at(index)
+        perform_deletion_operations(object)
+        super
+      end
+
+      # Removes all the objects contained in the list and updates their
+      # reference counts.
+      #
+      # @return [void]
+      #
+      def clear
+        objects.each do |object|
+          perform_deletion_operations(object)
+        end
+        super
+      end
+
+      # Moves the given object to the given index.
+      #
+      # @param [AbstractObject, ObjectDictionary] object
+      #        The object to move.
+      #
+      # @param [Fixnum] to
+      #        The new index for the object.
+      #
+      # @return [void]
+      #
+      def move(object, new_index)
+        return if index(object) == new_index
+        if obj = delete(object)
+          insert(new_index, obj)
+        else
+          raise "Attempt to move object `#{object}` not present in the list `#{inspect}`"
+        end
+      end
+
+      # Moves the object at the given index to the given position.
+      #
+      # @param [Fixnum] from
+      #        The current index of the object.
+      #
+      # @param [Fixnum] to
+      #        The new index for the object.
+      #
+      # @return [void]
+      #
+      def move_from(current_index, new_index)
+        return if current_index == new_index
+        if obj = delete_at(current_index)
+          insert(new_index, obj)
+        else
+          raise "Attempt to move object from index `#{current_index}` which is beyond bounds of the list `#{inspect}`"
+        end
+      end
+
+      def sort!
+        return super if owner.project.dirty?
+        previous = to_a
+        super
+        owner.mark_project_as_dirty! unless previous == to_a
+        self
+      end
+
+      private
+
+      # @!group Notification Methods
+      #------------------------------------------------------------------------#
+
+      # Informs an object that it was added to the list. In practice it adds
+      # the owner of the list as referrer to the objects. It also validates the
+      # value.
+      #
+      # @return [void]
+      #
+      def perform_additions_operations(objects)
+        objects = [objects] unless objects.is_a?(Array)
+        objects.each do |obj|
+          owner.mark_project_as_dirty!
+          obj.add_referrer(owner)
+          attribute.validate_value(obj) unless obj.is_a?(ObjectDictionary)
+        end
+      end
+
+      # Informs an object that it was removed from to the list, so it can
+      # remove its owner from its referrers and take the appropriate actions.
+      #
+      # @return [void]
+      #
+      def perform_deletion_operations(objects)
+        objects = [objects] unless objects.is_a?(Array)
+        objects.each do |obj|
+          owner.mark_project_as_dirty!
+          obj.remove_referrer(owner) unless obj.is_a?(ObjectDictionary)
+        end
+      end
+    end
+  end
+end