xcodeproj 1.3.3 → 1.4.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xcodeproj
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.4.0
 platform: ruby
 authors:
 - Eloy Duran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-20 00:00:00.000000000 Z
+date: 2016-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3'
 - !ruby/object:Gem::Dependency
-  name: colored
+  name: CFPropertyList
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: 2.3.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: 2.3.3
 - !ruby/object:Gem::Dependency
   name: claide
   requirement: !ruby/object:Gem::Requirement
@@ -58,6 +58,34 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: colored
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: nanaimo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 description: Xcodeproj lets you create and modify Xcode projects from Ruby. Script
   boring management tasks or build Xcode-friendly libraries. Also includes support
   for Xcode workspaces (.xcworkspace) and configuration files (.xcconfig).
@@ -84,11 +112,6 @@ files:
 - lib/xcodeproj/gem_version.rb
 - lib/xcodeproj/helper.rb
 - lib/xcodeproj/plist.rb
-- lib/xcodeproj/plist/ffi.rb
-- lib/xcodeproj/plist/ffi/chdir_override.rb
-- lib/xcodeproj/plist/ffi/core_foundation.rb
-- lib/xcodeproj/plist/ffi/dev_tools_core.rb
-- lib/xcodeproj/plist/plist_gem.rb
 - lib/xcodeproj/project.rb
 - lib/xcodeproj/project/case_converter.rb
 - lib/xcodeproj/project/object.rb
@@ -150,7 +173,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.6.7
 signing_key: 
 specification_version: 3
 summary: Create and modify Xcode projects from Ruby.

data/lib/xcodeproj/plist/ffi.rb

@@ -1,153 +0,0 @@
-
-module Xcodeproj
-  module Plist
-    # Provides support for loading and serializing property list files via
-    # Fiddle and CoreFoundation / Xcode.
-    #
-    module FFI
-      autoload :CoreFoundation, 'xcodeproj/plist/ffi/core_foundation'
-      autoload :DevToolsCore,   'xcodeproj/plist/ffi/dev_tools_core'
-
-      class << self
-        # Attempts to load the `fiddle` and Xcode based plist serializer.
-        #
-        # @return [String,Nil] The loading error message, or `nil` if loading
-        #         was successful.
-        #
-        def attempt_to_load!
-          return @attempt_to_load if defined?(@attempt_to_load)
-          @attempt_to_load = begin
-            require 'fiddle'
-            nil
-          rescue LoadError
-            'Xcodeproj relies on a library called `fiddle` to read and write ' \
-            'Xcode project files. Ensure your Ruby installation includes ' \
-            '`fiddle` and try again.'
-          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 write_to_path(hash, path)
-          raise ThreadError, 'Can only write plists from the main thread.' unless Thread.current == Thread.main
-
-          path = File.expand_path(path)
-
-          should_fork = ENV['FORK_XCODE_WRITING']
-          success = ruby_hash_write_xcode(hash, path, should_fork)
-
-          unless success
-            CoreFoundation.RubyHashPropertyListWrite(hash, path)
-            fix_encoding(path)
-          end
-        end
-
-        # @return [Hash] Returns the native objects loaded from a property list
-        #         file.
-        #
-        # @param  [#to_s] path
-        #         The path of the file.
-        #
-        def read_from_path(path)
-          CoreFoundation.RubyHashPropertyListRead(path)
-        end
-
-        private
-
-        # Simple workaround to escape characters which are outside of ASCII
-        # character-encoding. Relies on the fact that there are no XML characters
-        # which would need to be escaped.
-        #
-        # @note   This is necessary because Xcode (4.6 currently) uses the MacRoman
-        #         encoding unless the `// !$*UTF8*$!` magic comment is present. It
-        #         is not possible to serialize a plist using the NeXTSTEP format
-        #         without access to the private classes of Xcode and that comment
-        #         is not compatible with the XML format. For the complete
-        #         discussion see CocoaPods/CocoaPods#926.
-        #
-        #
-        # @note   Sadly this hack is not sufficient for supporting Emoji.
-        #
-        # @param  [String, Pathname] The path of the file which needs to be fixed.
-        #
-        # @return [void]
-        #
-        def fix_encoding(filename)
-          output = ''
-          input = File.open(filename, 'rb', &:read)
-          input.unpack('U*').each do |codepoint|
-            if codepoint > 127 # ASCII is 7-bit, so 0-127 are valid characters
-              output << "&##{codepoint};"
-            else
-              output << codepoint.chr
-            end
-          end
-          File.open(filename, 'wb') { |file| file.write(output) }
-        end
-
-        # Serializes a hash as an ASCII plist, using Xcode.
-        #
-        # @param  [Hash] hash
-        #         The hash to store.
-        #
-        # @param  [String] path
-        #         The path of the file.
-        #
-        def ruby_hash_write_xcode(hash, path, should_fork)
-          return false unless path.end_with?('pbxproj')
-          if should_fork
-            require 'open3'
-            _output, status = Open3.capture2e(Gem.ruby, '-e', <<-RUBY, path, :stdin_data => Marshal.dump(hash))
-            $LOAD_PATH.replace #{$LOAD_PATH}
-            path = ARGV.first
-            hash = Marshal.load(STDIN)
-            require "xcodeproj"
-            require "xcodeproj/plist/ffi"
-            ffi = Xcodeproj::Plist::FFI
-            success = ffi::DevToolsCore.load_xcode_frameworks && ffi.send(:ruby_hash_write_devtoolscore, hash, path)
-            exit(success ? 0 : 1)
-            RUBY
-
-            status.success?
-          else
-            monkey_patch_chdir
-            success = DevToolsCore.load_xcode_frameworks && ruby_hash_write_devtoolscore(hash, path)
-
-            success
-          end
-        end
-
-        def ruby_hash_write_devtoolscore(hash, path)
-          success = true
-
-          begin
-            plist = DevToolsCore::CFDictionary.new(CoreFoundation.RubyHashToCFDictionary(hash))
-            data = DevToolsCore::NSData.new(plist.plistDescriptionUTF8Data)
-            success &= data.writeToFileAtomically(path)
-
-            project = DevToolsCore::PBXProject.new(path)
-            success &= project.writeToFileSystemProjectFile
-            project.close
-          rescue Fiddle::DLError
-            success = false
-          end
-
-          success
-        end
-
-        def monkey_patch_chdir
-          require 'xcodeproj/plist/ffi/chdir_override'
-          class << Dir
-            alias_method :chdir, :cp_chdir
-          end
-        end
-      end
-    end
-  end
-end

data/lib/xcodeproj/plist/ffi/chdir_override.rb

@@ -1,27 +0,0 @@
-# Since Xcode 8 beta 4, calling `PBXProject.projectWithFile` breaks subsequent calls to
-# `chdir`. While sounding ridiculous, this is unfortunately true and debugging it from the
-# userland side showed no difference at all to successful calls to `chdir`, but the working
-# directory is simply not changed in the end. This workaround is even more absurd, monkey
-# patching all calls to `chdir` to use `__pthread_chdir` which appears to work.
-class Dir
-  def self.cp_chdir(path)
-    old_dir = Dir.getwd
-    res = cp_actually_chdir(path)
-
-    if block_given?
-      begin
-        return yield
-      ensure
-        cp_actually_chdir(old_dir)
-      end
-    end
-
-    res
-  end
-
-  def self.cp_actually_chdir(path)
-    libc = Fiddle.dlopen '/usr/lib/libc.dylib'
-    f = Fiddle::Function.new(libc['__pthread_chdir'], [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
-    f.call(path.to_s)
-  end
-end

data/lib/xcodeproj/plist/ffi/core_foundation.rb

@@ -1,441 +0,0 @@
-require 'fiddle'
-
-module Xcodeproj
-  module Plist
-    module FFI
-      # This module provides an interface to the CoreFoundation OS X framework.
-      # Specifically it bridges the functions required to be able to read and write
-      # property lists.
-      #
-      # Everything in here should be considered an implementation detail and thus is
-      # not further documented.
-      #
-      # @todo Move this out into its own gem.
-      #
-      # @!visibility private
-      #
-      module CoreFoundation
-        PATH = '/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation'
-
-        # rubocop:disable Style/MethodName
-        # rubocop:disable Style/VariableName
-
-        # @!group Ruby hash as property list (de)serialization
-        #---------------------------------------------------------------------------#
-
-        def self.RubyHashPropertyListWrite(hash, path)
-          url = CFURLCreateFromFileSystemRepresentation(NULL,
-                                                        path,
-                                                        path.bytesize,
-                                                        FALSE)
-          stream = CFWriteStreamCreateWithFile(NULL, url)
-          unless CFWriteStreamOpen(stream) == TRUE
-            raise IOError, 'Unable to open stream.'
-          end
-
-          plist = RubyHashToCFDictionary(hash)
-
-          error_ptr = CFTypeRefPointer()
-          result = CFPropertyListWrite(plist,
-                                       stream,
-                                       KCFPropertyListXMLFormat_v1_0,
-                                       0,
-                                       error_ptr)
-          CFWriteStreamClose(stream)
-
-          if result == 0
-            description = CFCopyDescription(error_ptr.ptr)
-            raise IOError, "Unable to write plist data: #{description}"
-          end
-          result
-        end
-
-        def self.RubyHashPropertyListRead(path)
-          url = CFURLCreateFromFileSystemRepresentation(NULL,
-                                                        path,
-                                                        path.bytesize,
-                                                        FALSE)
-          stream = CFReadStreamCreateWithFile(NULL, url)
-          unless CFReadStreamOpen(stream) == TRUE
-            raise IOError, 'Unable to open stream.'
-          end
-
-          error_ptr = CFTypeRefPointer()
-          plist = CFPropertyListCreateWithStream(NULL,
-                                                 stream,
-                                                 0,
-                                                 KCFPropertyListImmutable,
-                                                 NULL,
-                                                 error_ptr)
-          CFReadStreamClose(stream)
-
-          if plist.null?
-            description = CFCopyDescription(error_ptr.ptr)
-            raise IOError, "Unable to read plist data: #{description}"
-          elsif CFGetTypeID(plist) != CFDictionaryGetTypeID()
-            raise TypeError, 'Expected a plist with a dictionary root object.'
-          end
-
-          CFDictionaryToRubyHash(plist)
-        end
-
-        # @!group Types
-        #---------------------------------------------------------------------------#
-
-        # rubocop:disable Style/ConstantName
-
-        NULL = Fiddle::NULL
-
-        Void = Fiddle::TYPE_VOID
-        VoidPointer = Fiddle::TYPE_VOIDP
-        FunctionPointer = VoidPointer
-
-        UInt32 = -Fiddle::TYPE_INT
-        UInt8 = -Fiddle::TYPE_CHAR
-
-        SInt32Pointer = VoidPointer
-        UInt8Pointer = VoidPointer
-        CharPointer = VoidPointer
-
-        Boolean = Fiddle::TYPE_CHAR
-        TRUE = 1
-        FALSE = 0
-
-        SINT64_MAX = 2**63 - 1
-        SINT64_MIN = -SINT64_MAX - 1
-
-        SIZEOF_SINT64 = 8
-        SIZEOF_FLOAT64 = 8
-
-        SINT64_PACK_TEMPLATE = 'q'
-        FLOAT64_PACK_TEMPLATE = 'd'
-
-        CFTypeRef = VoidPointer
-        CFTypeRefPointer = VoidPointer
-        CFIndex = Fiddle::TYPE_LONG
-        CFTypeID = -Fiddle::TYPE_LONG
-        CFOptionFlags = UInt32
-
-        CFPropertyListMutabilityOptions = Fiddle::TYPE_INT
-        KCFPropertyListImmutable = 0
-
-        CFPropertyListFormat = Fiddle::TYPE_INT
-        KCFPropertyListXMLFormat_v1_0 = 100
-        CFPropertyListFormatPointer = VoidPointer
-
-        CFStringEncoding = UInt32
-        KCFStringEncodingUTF8 = 0x08000100
-
-        CFNumberType = Fiddle::TYPE_INT
-        KCFNumberSInt64Type = 4
-        KCFNumberFloat64Type = 6
-
-        # rubocop:enable Style/ConstantName
-
-        private
-
-        # @!group Helpers
-        #---------------------------------------------------------------------------#
-
-        def self.image
-          @image ||= Fiddle.dlopen(PATH)
-        end
-
-        def self.free_function
-          @free_function ||= Fiddle::Function.new(Fiddle::Handle.new['free'], [VoidPointer], Void)
-        end
-
-        def self.CFRelease_function
-          @CFRelease ||= Fiddle::Function.new(image['CFRelease'], [CFTypeRef], Void)
-        end
-
-        def self.extern_image(image, symbol, parameter_types, return_type)
-          symbol = symbol.to_s
-          create_function = symbol.include?('Create')
-          function_cache_key = "@__#{symbol}__"
-
-          # Define a singleton method on the CoreFoundation module.
-          define_singleton_method(symbol) do |*args|
-            unless args.size == parameter_types.size
-              raise ArgumentError, "wrong number of arguments (#{args.size} for " \
-                                   "#{parameter_types.size})"
-            end
-
-            unless function = instance_variable_get(function_cache_key)
-              function = Fiddle::Function.new(image[symbol],
-                                              parameter_types,
-                                              return_type)
-              instance_variable_set(function_cache_key, function)
-            end
-
-            result = function.call(*args)
-            create_function ? CFAutoRelease(result) : result
-          end
-        end
-
-        def self.extern(symbol, parameter_types, return_type)
-          extern_image(image, symbol, parameter_types, return_type)
-        end
-
-        public
-
-        # @!group CoreFoundation function definitions
-        #---------------------------------------------------------------------------#
-
-        # CFTypeRef description
-        extern :CFShow, [CFTypeRef], Void
-        extern :CFCopyDescription, [CFTypeRef], CFTypeRef
-
-        # CFType reflection
-        extern :CFGetTypeID, [CFTypeRef], CFTypeID
-        extern :CFDictionaryGetTypeID, [], CFTypeID
-        extern :CFStringGetTypeID, [], CFTypeID
-        extern :CFArrayGetTypeID, [], CFTypeID
-        extern :CFBooleanGetTypeID, [], CFTypeID
-        extern :CFNumberGetTypeID, [], CFTypeID
-
-        # CFStream
-        extern :CFWriteStreamCreateWithFile, [CFTypeRef, CFTypeRef], CFTypeRef
-        extern :CFWriteStreamOpen, [CFTypeRef], Boolean
-        extern :CFWriteStreamClose, [CFTypeRef], Void
-        extern :CFReadStreamCreateWithFile, [CFTypeRef, CFTypeRef], CFTypeRef
-        extern :CFReadStreamOpen, [CFTypeRef], Boolean
-        extern :CFReadStreamClose, [CFTypeRef], Void
-
-        # CFURL
-        extern :CFURLCreateFromFileSystemRepresentation, [CFTypeRef, UInt8Pointer, CFIndex, Boolean], CFTypeRef
-
-        # CFPropertyList
-        extern :CFPropertyListWrite, [CFTypeRef, CFTypeRef, CFPropertyListFormat, CFOptionFlags, CFTypeRefPointer], CFIndex
-        extern :CFPropertyListCreateWithStream, [CFTypeRef, CFTypeRef, CFIndex, CFOptionFlags, CFPropertyListFormatPointer, CFTypeRefPointer], CFTypeRef
-
-        # CFString
-        extern :CFStringCreateExternalRepresentation, [CFTypeRef, CFTypeRef, CFStringEncoding, UInt8], CFTypeRef
-        extern :CFStringCreateWithCString, [CFTypeRef, CharPointer, CFStringEncoding], CFTypeRef
-
-        # CFData
-        extern :CFDataGetLength, [CFTypeRef], CFIndex
-        extern :CFDataGetBytePtr, [CFTypeRef], VoidPointer
-
-        # CFDictionary
-        extern :CFDictionaryCreateMutable, [CFTypeRef, CFIndex, VoidPointer, VoidPointer], CFTypeRef
-        extern :CFDictionaryAddValue, [CFTypeRef, CFTypeRef, CFTypeRef], VoidPointer
-        extern :CFDictionaryApplyFunction, [CFTypeRef, FunctionPointer, VoidPointer], Void
-
-        # CFArray
-        extern :CFArrayCreateMutable, [CFTypeRef, CFIndex, VoidPointer], CFTypeRef
-        extern :CFArrayAppendValue, [CFTypeRef, CFTypeRef], VoidPointer
-        extern :CFArrayGetCount, [CFTypeRef], CFIndex
-        extern :CFArrayGetValueAtIndex, [CFTypeRef, CFIndex], CFTypeRef
-
-        # CFBoolean
-        extern :CFBooleanGetValue, [CFTypeRef], Boolean
-
-        # CFNumber
-        extern :CFNumberIsFloatType, [CFTypeRef], Boolean
-        extern :CFNumberGetValue, [CFTypeRef, CFNumberType, VoidPointer], Boolean
-        extern :CFNumberCreate, [CFTypeRef, CFNumberType, VoidPointer], CFTypeRef
-
-        # @!group Custom convenience functions
-        #---------------------------------------------------------------------------#
-
-        def self.CFBooleanTrue
-          @CFBooleanTrue ||= Fiddle::Pointer.new(image['kCFBooleanTrue']).ptr
-        end
-
-        def self.CFBooleanFalse
-          @CFBooleanFalse ||= Fiddle::Pointer.new(image['kCFBooleanFalse']).ptr
-        end
-
-        def self.CFTypeArrayCallBacks
-          @CFTypeArrayCallBacks ||= image['kCFTypeArrayCallBacks']
-        end
-
-        def self.CFTypeDictionaryKeyCallBacks
-          @CFTypeDictionaryKeyCallBacks ||= image['kCFTypeDictionaryKeyCallBacks']
-        end
-
-        def self.CFTypeDictionaryValueCallBacks
-          @CFTypeDictionaryValueCallBacks ||= image['kCFTypeDictionaryValueCallBacks']
-        end
-
-        # This pointer will assign `CFRelease` as the free function when
-        # dereferencing the pointer.
-        #
-        # @note This means that the object will *not* be released if it's not
-        #       dereferenced, but that would be a leak anyways, so be sure to do so.
-        #
-        def self.CFTypeRefPointer
-          pointer = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INTPTR_T, free_function)
-          def pointer.ptr
-            ::CoreFoundation.CFAutoRelease(super)
-          end
-          pointer
-        end
-
-        def self.CFAutoRelease(cf_type_reference)
-          cf_type_reference.free = CFRelease_function() unless cf_type_reference.null?
-          cf_type_reference
-        end
-
-        def self.CFDictionaryApplyBlock(dictionary, &applier)
-          param_types = [CFTypeRef, CFTypeRef, VoidPointer]
-          closure = Fiddle::Closure::BlockCaller.new(Void, param_types, &applier)
-          closure_function = Fiddle::Function.new(closure, param_types, Void)
-          CFDictionaryApplyFunction(dictionary, closure_function, NULL)
-        end
-
-        def self.CFArrayApplyBlock(array)
-          CFArrayGetCount(array).times do |index|
-            yield CFArrayGetValueAtIndex(array, index)
-          end
-        end
-
-        # @!group CFTypeRef to Ruby value conversion
-        #---------------------------------------------------------------------------#
-
-        def self.CFTypeRefToRubyValue(cf_type_reference)
-          case CFGetTypeID(cf_type_reference)
-          when CFStringGetTypeID()
-            CFStringToRubyString(cf_type_reference)
-          when CFDictionaryGetTypeID()
-            CFDictionaryToRubyHash(cf_type_reference)
-          when CFArrayGetTypeID()
-            CFArrayToRubyArray(cf_type_reference)
-          when CFBooleanGetTypeID()
-            CFBooleanToRubyBoolean(cf_type_reference)
-          when CFNumberGetTypeID()
-            CFNumberToRubyNumber(cf_type_reference)
-          else
-            description = CFStringToRubyString(CFCopyDescription(cf_type_reference))
-            raise TypeError, "Unknown type: #{description}"
-          end
-        end
-
-        def self.CFStringToRubyString(string)
-          data = CFStringCreateExternalRepresentation(NULL,
-                                                      string,
-                                                      KCFStringEncodingUTF8,
-                                                      0)
-          if data.null?
-            raise TypeError, 'Unable to convert CFStringRef.'
-          end
-          bytes_ptr = CFDataGetBytePtr(data)
-          result = bytes_ptr.to_str(CFDataGetLength(data))
-          result.force_encoding(Encoding::UTF_8)
-          result
-        end
-
-        def self.CFDictionaryToRubyHash(dictionary)
-          result = {}
-          CFDictionaryApplyBlock(dictionary) do |key, value|
-            result[CFStringToRubyString(key)] = CFTypeRefToRubyValue(value)
-          end
-          result
-        end
-
-        def self.CFArrayToRubyArray(array)
-          result = []
-          CFArrayApplyBlock(array) do |element|
-            result << CFTypeRefToRubyValue(element)
-          end
-          result
-        end
-
-        def self.CFBooleanToRubyBoolean(boolean)
-          CFBooleanGetValue(boolean) == TRUE
-        end
-
-        def self.CFNumberToRubyNumber(number)
-          if CFNumberIsFloatType(number) == FALSE
-            value_type = KCFNumberSInt64Type
-            pack_template = SINT64_PACK_TEMPLATE
-            size = SIZEOF_SINT64
-          else
-            value_type = KCFNumberFloat64Type
-            pack_template = FLOAT64_PACK_TEMPLATE
-            size = SIZEOF_FLOAT64
-          end
-          ptr = Fiddle::Pointer.malloc(size)
-          CFNumberGetValue(number, value_type, ptr)
-          ptr.to_str.unpack(pack_template).first
-        end
-
-        # @!group Ruby value to CFTypeRef conversion
-        #---------------------------------------------------------------------------#
-
-        def self.RubyValueToCFTypeRef(value)
-          result = case value
-                   when String
-                     RubyStringToCFString(value)
-                   when Hash
-                     RubyHashToCFDictionary(value)
-                   when Array
-                     RubyArrayToCFArray(value)
-                   when true, false
-                     RubyBooleanToCFBoolean(value)
-                   when Numeric
-                     RubyNumberToCFNumber(value)
-                   else
-                     RubyStringToCFString(value.to_s)
-                   end
-          if result.null?
-            raise TypeError, "Unable to convert Ruby value `#{value.inspect}' " \
-                             'into a CFTypeRef.'
-          end
-          result
-        end
-
-        def self.RubyStringToCFString(string)
-          CFStringCreateWithCString(NULL,
-                                    Fiddle::Pointer[string.encode('UTF-8')],
-                                    KCFStringEncodingUTF8)
-        end
-
-        def self.RubyHashToCFDictionary(hash)
-          result = CFDictionaryCreateMutable(NULL,
-                                             0,
-                                             CFTypeDictionaryKeyCallBacks(),
-                                             CFTypeDictionaryValueCallBacks())
-          hash.each do |key, value|
-            key = RubyStringToCFString(key.to_s)
-            value = RubyValueToCFTypeRef(value)
-            CFDictionaryAddValue(result, key, value)
-          end
-          result
-        end
-
-        def self.RubyArrayToCFArray(array)
-          result = CFArrayCreateMutable(NULL, 0, CFTypeArrayCallBacks())
-          array.each do |element|
-            element = RubyValueToCFTypeRef(element)
-            CFArrayAppendValue(result, element)
-          end
-          result
-        end
-
-        def self.RubyNumberToCFNumber(value)
-          case value
-          when Float
-            value_type = KCFNumberFloat64Type
-            pack_template = FLOAT64_PACK_TEMPLATE
-          when SINT64_MIN..SINT64_MAX
-            value_type = KCFNumberSInt64Type
-            pack_template = SINT64_PACK_TEMPLATE
-          else # the value is too big to be stored in a CFNumber so store it as a CFString
-            return RubyStringToCFString(value.to_s)
-          end
-          ptr = Fiddle::Pointer.to_ptr([value].pack(pack_template))
-          CFNumberCreate(NULL, value_type, ptr)
-        end
-
-        def self.RubyBooleanToCFBoolean(value)
-          value ? CFBooleanTrue() : CFBooleanFalse()
-        end
-
-        # rubocop:enable Style/MethodName
-        # rubocop:enable Style/VariableName
-      end
-    end
-  end
-end