plasmo_xcodeproj 1.21.1

data/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/lib/xcodeproj/gem_version.rb

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

data/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/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/lib/xcodeproj/project/case_converter.rb

@@ -0,0 +1,90 @@
+module Xcodeproj
+  class Project
+    module Object
+      # Converts between camel case names used in the xcodeproj plist files
+      # and the ruby symbols used to represent them.
+      #
+      module CaseConverter
+        # @return [String] The plist equivalent of the given Ruby name.
+        #
+        # @param  [Symbol, String] name
+        #         The name to convert
+        #
+        # @param  [Symbol, Nil] type
+        #         The type of conversion. Pass `nil` for normal camel case and
+        #         `:lower` for camel case starting with a lower case letter.
+        #
+        # @example
+        #   CaseConverter.convert_to_plist(:project_ref) #=> ProjectRef
+        #
+        def self.convert_to_plist(name, type = nil)
+          case name
+          when :remote_global_id_string
+            'remoteGlobalIDString'
+          else
+            if type == :lower
+              cache = plist_cache[:lower] ||= {}
+              cache[name] ||= camelize(name, :uppercase_first_letter => false)
+            else
+              cache = plist_cache[:normal] ||= {}
+              cache[name] ||= camelize(name)
+            end
+          end
+        end
+
+        # The following two methods are taken from activesupport,
+        # https://github.com/rails/rails/blob/v5.0.2/activesupport/lib/active_support/inflector/methods.rb
+        # all credit for them goes to the original authors.
+        #
+        # The code is used under the MIT license.
+
+        def self.camelize(term, uppercase_first_letter: true)
+          string = term.to_s
+          string = if uppercase_first_letter
+                     string.sub(/^[a-z\d]*/, &:capitalize)
+                   else
+                     string.sub(/^(?:(?=a)b(?=\b|[A-Z_])|\w)/, &:downcase)
+                   end
+          string.gsub!(%r{(?:_|(/))([a-z\d]*)}i) { "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}" }
+          string.gsub!('/'.freeze, '::'.freeze)
+          string
+        end
+        private_class_method :camelize
+
+        def self.underscore(camel_cased_word)
+          return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
+          word = camel_cased_word.to_s.gsub('::'.freeze, '/'.freeze)
+          word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)((?=a)b)(?=\b|[^a-z])/) { "#{Regexp.last_match(1) && '_'.freeze}#{Regexp.last_match(2).downcase}" }
+          word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
+          word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
+          word.tr!('-'.freeze, '_'.freeze)
+          word.downcase!
+          word
+        end
+        private_class_method :underscore
+
+        # @return [Symbol] The Ruby equivalent of the given plist name.
+        #
+        # @param  [String] name
+        #         The name to convert
+        #
+        # @example
+        #   CaseConverter.convert_to_ruby('ProjectRef') #=> :project_ref
+        #
+        def self.convert_to_ruby(name)
+          underscore(name.to_s).to_sym
+        end
+
+        # @return [Hash] A cache for the conversion to the Plist format.
+        #
+        # @note   A cache is used because this operation is performed for each
+        #         attribute of the project when it is saved and caching it has
+        #         an important performance benefit.
+        #
+        def self.plist_cache
+          @plist_cache ||= {}
+        end
+      end
+    end
+  end
+end