cocoapods-mangle 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dc1d2558cf99da5046d0a14bb829edcc388102eb
+  data.tar.gz: a0143366854142cfa87237dcf9d4eb2765f901b8
+SHA512:
+  metadata.gz: b0961a1e50462566b277684d752226c52f296198550578976f986543ca5f9d9c6fc901c1a2d504f97f0b6e7ccf7337cab31f06fb130c8f46782bc19c212c4281
+  data.tar.gz: bfd293bdd875576e88774fae3cdb39134e04ae4b46962ee5cc5af1a63e1a8c059b27dbc02a74f61952c7cce6914add6983bf962f9e8486d099d7bd35d3da078d

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# cocoapods-mangle changelog
+
+## 1.0.0 (2017-12-08)
+
+* Initial release of cocoapods-mangle with support for mangling source Objective C dependencies.

data/README.md

@@ -0,0 +1,127 @@
+![Intercom](Intercom_logo-github.png)
+
+[![Apache License](http://img.shields.io/badge/license-APACHE2-blue.svg?style=flat)](https://www.apache.org/licenses/LICENSE-2.0.html)
+[![CircleCI](https://circleci.com/gh/intercom/cocoapods-mangle.svg?style=svg)](https://circleci.com/gh/intercom/cocoapods-mangle)
+
+# cocoapods-mangle
+
+cocoapods-mangle is a CocoaPods plugin which mangles the symbols of your dependencies. Mangling your dependencies' symbols allows more than one copy of a dependency to exist in an app. This is particularly useful for iOS frameworks which do not want to interfere with the host app.
+
+## Installation
+
+    $ gem install cocoapods-mangle
+
+## What is mangling?
+
+Mangling or namespacing your dependencies is a way of ensuring that there are no conflicts between multiple copies of the same dependency in an app. This is most useful when developing third-party frameworks.
+
+For example, if you are developing a framework `MyFramework.framework` and you include `AFNetworking` as a dependency, all `AFNetworking` classes are included in your framework's binary:
+
+```
+➜ nm -gU MyFramework.framework/MyFramework | grep "_OBJC_CLASS_\$.*AF.*"
+00000000000000e0 S _OBJC_CLASS_$_PodsDummy_AFNetworking
+00000000000013f0 S _OBJC_CLASS_$_AFNetworkReachabilityManager
+0000000000001f20 S _OBJC_CLASS_$_AFSecurityPolicy
+000000000000a938 S _OBJC_CLASS_$_AFHTTPBodyPart
+000000000000a898 S _OBJC_CLASS_$_AFHTTPRequestSerializer
+000000000000a9d8 S _OBJC_CLASS_$_AFJSONRequestSerializer
+000000000000a910 S _OBJC_CLASS_$_AFMultipartBodyStream
+000000000000aa28 S _OBJC_CLASS_$_AFPropertyListRequestSerializer
+000000000000a848 S _OBJC_CLASS_$_AFQueryStringPair
+000000000000a8c0 S _OBJC_CLASS_$_AFStreamingMultipartFormData
+0000000000004870 S _OBJC_CLASS_$_AFCompoundResponseSerializer
+00000000000046e0 S _OBJC_CLASS_$_AFHTTPResponseSerializer
+0000000000004820 S _OBJC_CLASS_$_AFImageResponseSerializer
+0000000000004730 S _OBJC_CLASS_$_AFJSONResponseSerializer
+00000000000047d0 S _OBJC_CLASS_$_AFPropertyListResponseSerializer
+0000000000004780 S _OBJC_CLASS_$_AFXMLParserResponseSerializer
+```
+
+This means that if an app includes both `MyFramework.framework` and `AFNetworking`, the app will fail to build with an error that looks something like:
+
+```
+ld: 16 duplicate symbols for architecture x86_64
+clang: error: linker command failed with exit code 1 (use -v to see invocation)
+```
+
+However, with mangling enabled through cocoapods-mangle, we can see that the `AFNetworking` classes are now prefixed with `MyFramework_`:
+
+```
+➜ nm -gU MyFramework.framework/MyFramework | grep "_OBJC_CLASS_\$.*AF.*"
+00000000000000e0 S _OBJC_CLASS_$_MyFramework_PodsDummy_AFNetworking
+00000000000013f0 S _OBJC_CLASS_$_MyFramework_AFNetworkReachabilityManager
+0000000000001f20 S _OBJC_CLASS_$_MyFramework_AFSecurityPolicy
+000000000000a938 S _OBJC_CLASS_$_MyFramework_AFHTTPBodyPart
+000000000000a898 S _OBJC_CLASS_$_MyFramework_AFHTTPRequestSerializer
+000000000000a9d8 S _OBJC_CLASS_$_MyFramework_AFJSONRequestSerializer
+000000000000a910 S _OBJC_CLASS_$_MyFramework_AFMultipartBodyStream
+000000000000aa28 S _OBJC_CLASS_$_MyFramework_AFPropertyListRequestSerializer
+000000000000a848 S _OBJC_CLASS_$_MyFramework_AFQueryStringPair
+000000000000a8c0 S _OBJC_CLASS_$_MyFramework_AFStreamingMultipartFormData
+0000000000004870 S _OBJC_CLASS_$_MyFramework_AFCompoundResponseSerializer
+00000000000046e0 S _OBJC_CLASS_$_MyFramework_AFHTTPResponseSerializer
+0000000000004820 S _OBJC_CLASS_$_MyFramework_AFImageResponseSerializer
+0000000000004730 S _OBJC_CLASS_$_MyFramework_AFJSONResponseSerializer
+00000000000047d0 S _OBJC_CLASS_$_MyFramework_AFPropertyListResponseSerializer
+0000000000004780 S _OBJC_CLASS_$_MyFramework_AFXMLParserResponseSerializer
+```
+
+The app that includes both `MyFramework.framework` and `AFNetworking` will now build successfully 🎉
+
+## How it works
+
+As demonstrated above, `nm` can be used to inspect the symbols such as classes, constants and selectors in a Mach-O binary. When you run `pod install`, cocoapods-mangle builds your dependencies if they have changed, and parses the output of `nm`. It places this output in an `xcconfig` file that looks something like this:
+
+```
+MANGLING_DEFINES = PodsDummy_AFNetworking=MyFramework_PodsDummy_AFNetworking AFNetworkReachabilityManager=MyFramework_AFNetworkReachabilityManager AFSecurityPolicy=MyFramework_AFSecurityPolicy AFHTTPBodyPart=MyFramework_AFHTTPBodyPart AFHTTPRequestSerializer=MyFramework_AFHTTPRequestSerializer AFJSONRequestSerializer=MyFramework_AFJSONRequestSerializer AFMultipartBodyStream=MyFramework_AFMultipartBodyStream AFPropertyListRequestSerializer=MyFramework_AFPropertyListRequestSerializer AFQueryStringPair=MyFramework_AFQueryStringPair AFStreamingMultipartFormData=MyFramework_AFStreamingMultipartFormData AFCompoundResponseSerializer=MyFramework_AFCompoundResponseSerializer AFHTTPResponseSerializer=MyFramework_AFHTTPResponseSerializer AFImageResponseSerializer=MyFramework_AFImageResponseSerializer AFJSONResponseSerializer=MyFramework_AFJSONResponseSerializer AFPropertyListResponseSerializer=MyFramework_AFPropertyListResponseSerializer AFXMLParserResponseSerializer=MyFramework_AFXMLParserResponseSerializer
+
+MANGLED_SPECS_CHECKSUM = 18f61e6e6172fb87ddc7341f3537f30f8c7a3edc
+```
+
+This is included in `GCC_PREPROCESSOR_DEFINITIONS` of the `xcconfig` file for every target. All of these symbols will be mangled on subsequent builds.
+
+The symbols that will be mangled are:
+
+- Objective C classes. e.g. `AFNetworkReachabilityManager` becomes `MyFramework_AFNetworkReachabilityManager`.
+- C and Objective C constants. `AFNetworkingReachabilityDidChangeNotification` becomes `MyFramework_AFNetworkingReachabilityDidChangeNotification`.
+- Objective C category selectors. The first component of the selector is mangled. e.g. `-[NSString xxx_abc:def]` becomes `-[NSString MyFramework_xxx_abc:def]`.
+
+The plugin has only been fully tested with Objective C dependencies. There is no reason why this could not also work for Swift.
+
+## Usage
+
+cocoapods-mangle can be used by adding it to your `Podfile` like this:
+
+```
+source 'https://github.com/CocoaPods/Specs.git'
+
+platform :ios, '8.0'
+plugin 'cocoapods-mangle'
+
+target :MyTarget do
+  # Dependencies here
+end
+
+```
+
+Now, each time you run `pod install`, cocoapods-mangle updates the `xcconfig` files for all targets to ensure that all symbols in your dependencies are mangled.
+
+The plugin can be optionally configured with `:xcconfig_path`, `:mangle_prefix` or `:targets`. Here is an example:
+
+```
+plugin 'cocoapods-mangle', targets: ['MyTarget'],
+                           mangle_prefix: 'Prefix_'
+                           xcconfig_path: 'path/to/mangle.xcconfig'
+```
+
+## Caveats
+
+- cocoapods-mangle will only work for source dependencies. Pre-compiled frameworks cannot be mangled.
+- Currently only supports iOS. It should be very straightforward to extend support to macOS, tvOS or watchOS.
+- Category mangling may cause issues if the dependency does not correctly prefix its category selectors (see http://nshipster.com/namespacing/#method-prefixes).
+
+## Related links
+
+- [CocoaPods Packager](https://github.com/cocoapods/cocoapods-packager) has similar mangling functionality for packaging `.podspec` files.
+- http://blog.sigmapoint.pl/avoiding-dependency-collisions-in-ios-static-library-managed-by-cocoapods/
+- http://pdx.esri.com/blog/namespacing-dependencies/

data/lib/cocoapods_mangle/builder.rb

@@ -0,0 +1,57 @@
+require 'cocoapods'
+
+module CocoapodsMangle
+  # Builds the supplied targets of a Pods Xcode project.
+  #
+  # This is useful for building pods for mangling purposes
+  class Builder
+    BUILD_DIR = 'build'
+    BUILT_PRODUCTS_DIR = "#{BUILD_DIR}/Release-iphonesimulator"
+
+    # @param    [String] pods_project_path
+    #           path to the pods project to build.
+    #
+    # @param    [Array<String>] pod_target_labels
+    #           the pod targets to build.
+    def initialize(pods_project_path, pod_target_labels)
+      @pods_project_path = pods_project_path
+      @pod_target_labels = pod_target_labels
+    end
+
+    # Build the pods project
+    def build!
+      FileUtils.remove_dir(BUILD_DIR, true)
+      @pod_target_labels.each { |target| build_target(target) }
+    end
+
+    # Gives the built binaries to be mangled
+    # @return  [Array<String>] Paths to the build pods binaries
+    def binaries_to_mangle
+      static_binaries_to_mangle + dynamic_binaries_to_mangle
+    end
+
+    private
+
+    def build_target(target)
+      Pod::UI.message "- Building '#{target}'"
+      output = `xcodebuild -project "#{@pods_project_path}" -target "#{target}" -configuration Release -sdk iphonesimulator build 2>&1`
+      unless $?.success?
+        raise "error: Building the Pods target '#{target}' failed.\ This is the build log:\n#{output}"
+      end
+    end
+
+    def static_binaries_to_mangle
+      Dir.glob("#{BUILT_PRODUCTS_DIR}/**/*.a").reject do |binary_path|
+        File.basename(binary_path).start_with?('libPods-')
+      end
+    end
+
+    def dynamic_binaries_to_mangle
+      frameworks = Dir.glob("#{BUILT_PRODUCTS_DIR}/**/*.framework")
+      framework = frameworks.reject do |framework_path|
+        File.basename(framework_path).start_with?('Pods_')
+      end
+      framework.map { |path| "#{path}/#{File.basename(path, '.framework')}" }
+    end
+  end
+end

data/lib/cocoapods_mangle/config.rb

@@ -0,0 +1,77 @@
+require 'xcodeproj'
+require 'cocoapods'
+require 'cocoapods_mangle/builder'
+require 'cocoapods_mangle/defines'
+
+module CocoapodsMangle
+  # Manages xcconfig files for configuring mangling.
+  class Config
+    MANGLING_DEFINES_XCCONFIG_KEY = 'MANGLING_DEFINES'
+    MANGLED_SPECS_CHECKSUM_XCCONFIG_KEY = 'MANGLED_SPECS_CHECKSUM'
+
+    # @param [CocoapodsMangle::Context] context The context for mangling.
+    def initialize(context)
+      @context = context
+    end
+
+    # Update the mangling xcconfig file with new mangling defines
+    def update_mangling!
+      Pod::UI.message '- Updating mangling xcconfig' do
+        builder = Builder.new(@context.pods_project_path, @context.pod_target_labels)
+        builder.build!
+
+        defines = Defines.mangling_defines(@context.mangle_prefix, builder.binaries_to_mangle)
+
+        contents = <<~MANGLE_XCCONFIG
+          // This config file is automatically generated any time Podfile.lock changes
+          // Changes should be committed to git along with Podfile.lock
+
+          #{MANGLING_DEFINES_XCCONFIG_KEY} = #{defines.join(' ')}
+
+          // This checksum is used to ensure mangling is up to date
+          #{MANGLED_SPECS_CHECKSUM_XCCONFIG_KEY} = #{@context.specs_checksum}
+        MANGLE_XCCONFIG
+
+        Pod::UI.message "- Writing '#{File.basename(@context.xcconfig_path)}'"
+        File.open(@context.xcconfig_path, 'w') { |xcconfig| xcconfig.write(contents) }
+      end
+    end
+
+    # Does the mangling xcconfig need to be updated?
+    # @return  [Truthy] Does the xcconfig need to be updated?
+    def needs_update?
+      return true unless File.exist?(@context.xcconfig_path)
+      xcconfig_hash = Xcodeproj::Config.new(File.new(@context.xcconfig_path)).to_hash
+      needs_update = xcconfig_hash[MANGLED_SPECS_CHECKSUM_XCCONFIG_KEY] != @context.specs_checksum
+      Pod::UI.message '- Mangling config already up to date' unless needs_update
+      needs_update
+    end
+
+    # Update all pod xcconfigs to use the mangling defines
+    def update_pod_xcconfigs_for_mangling!
+      Pod::UI.message '- Updating Pod xcconfig files' do
+        @context.pod_xcconfig_paths.each do |pod_xcconfig_path|
+          Pod::UI.message "- Updating '#{File.basename(pod_xcconfig_path)}'"
+          update_pod_xcconfig_for_mangling!(pod_xcconfig_path)
+        end
+      end
+    end
+
+    # Update a mangling config to use the mangling defines
+    # @param    [String] pod_xcconfig_path
+    #           Path to the pod xcconfig to update
+    def update_pod_xcconfig_for_mangling!(pod_xcconfig_path)
+      mangle_xcconfig_include = "#include \"#{@context.xcconfig_path}\"\n"
+
+      gcc_preprocessor_defs = File.readlines(pod_xcconfig_path).select { |line| line =~ /GCC_PREPROCESSOR_DEFINITIONS/ }.first
+      gcc_preprocessor_defs.strip!
+
+      xcconfig_contents = File.read(pod_xcconfig_path)
+      # import the mangling config
+      new_xcconfig_contents = mangle_xcconfig_include + xcconfig_contents
+      # update GCC_PREPROCESSOR_DEFINITIONS to include mangling
+      new_xcconfig_contents.sub!(gcc_preprocessor_defs, gcc_preprocessor_defs + " $(#{MANGLING_DEFINES_XCCONFIG_KEY})")
+      File.open(pod_xcconfig_path, 'w') { |pod_xcconfig| pod_xcconfig.write(new_xcconfig_contents) }
+    end
+  end
+end

data/lib/cocoapods_mangle/context.rb

@@ -0,0 +1,84 @@
+module CocoapodsMangle
+  # Context for mangling
+  class Context
+    # Initializes the context for mangling
+    # @param  [Pod::Installer::PostInstallHooksContext] installer_context
+    #         The post install context
+    # @param  [Hash] options
+    # @option options [String] :xcconfig_path
+    #                 The path to the mangling xcconfig
+    # @option options [String] :mangle_prefix
+    #                 The prefix to prepend to mangled symbols
+    # @option options [Array<String>] :targets
+    #                 The user targets whose dependencies should be mangled
+    def initialize(installer_context, options)
+      @installer_context = installer_context
+      @options = options
+    end
+
+    # @return [String] The path to the mangle xcconfig
+    def xcconfig_path
+      return default_xcconfig_path unless @options[:xcconfig_path]
+      File.join(@installer_context.sandbox.root.parent, @options[:xcconfig_path])
+    end
+
+    # @return [String] The mangle prefix to be used
+    def mangle_prefix
+      return default_mangle_prefix unless @options[:mangle_prefix]
+      @options[:mangle_prefix]
+    end
+
+    # @return [String] The path to pods project
+    def pods_project_path
+      @installer_context.pods_project.path
+    end
+
+    # @return [Array<String>] The targets in the pods project to be mangled
+    def pod_target_labels
+      umbrella_pod_targets.map(&:cocoapods_target_label)
+    end
+
+    # @return [Array<String>] Paths to all pod xcconfig files which should be updated
+    def pod_xcconfig_paths
+      pod_xcconfigs = []
+      @installer_context.pods_project.targets.each do |target|
+        target.build_configurations.each do |config|
+          pod_xcconfigs << config.base_configuration_reference.real_path
+        end
+      end
+      pod_xcconfigs.uniq
+    end
+
+    # @return [String] A checksum representing the current state of the target dependencies
+    def specs_checksum
+      gem_summary = "#{CocoapodsMangle::NAME}=#{CocoapodsMangle::VERSION}"
+      specs = umbrella_pod_targets.map(&:specs).flatten.uniq
+      specs_summary = specs.map(&:checksum).join(',')
+      Digest::SHA1.hexdigest("#{gem_summary},#{specs_summary}")
+    end
+
+    private
+
+    def umbrella_pod_targets
+      if @options[:targets].nil? || @options[:targets].empty?
+        return @installer_context.umbrella_targets
+      end
+      @installer_context.umbrella_targets.reject do |target|
+        target_names = target.user_targets.map(&:name)
+        (@options[:targets] & target_names).empty?
+      end
+    end
+
+    def default_xcconfig_path
+      xcconfig_dir = @installer_context.sandbox.target_support_files_root
+      xcconfig_filename = "#{CocoapodsMangle::NAME}.xcconfig"
+      File.join(xcconfig_dir, xcconfig_filename)
+    end
+
+    def default_mangle_prefix
+      project_path = umbrella_pod_targets.first.user_project.path
+      project_name = File.basename(project_path, '.xcodeproj')
+      project_name.tr(' ', '_') + '_'
+    end
+  end
+end

data/lib/cocoapods_mangle/defines.rb

@@ -0,0 +1,114 @@
+module CocoapodsMangle
+  # Generates mangling defines from a provided list of binaries
+  module Defines
+    # @param  [String] prefix
+    #         The prefix to prefix to mangled symbols
+    # @param  [Array<String>] binaries_to_mangle
+    #         The binaries containing symbols to be mangled
+    # @return [Array<String>] The mangling defines
+    def self.mangling_defines(prefix, binaries_to_mangle)
+      classes = classes(binaries_to_mangle)
+      constants = constants(binaries_to_mangle)
+      category_selectors = category_selectors(binaries_to_mangle, classes)
+
+      defines = prefix_symbols(prefix, classes)
+      defines += prefix_symbols(prefix, constants)
+      defines += prefix_selectors(prefix, category_selectors)
+      defines
+    end
+
+    # Get the classes defined in a list of binaries
+    # @param  [Array<String>] binaries
+    #         The binaries containing symbols to be mangled
+    # @return [Array<String>] The classes defined in the binaries
+    def self.classes(binaries)
+      all_symbols = run_nm(binaries, '-gU')
+      class_symbols = all_symbols.select do |symbol|
+        symbol[/OBJC_CLASS_\$_/]
+      end
+      class_symbols = class_symbols.map { |klass| klass.gsub(/^.*\$_/, '') }
+      class_symbols.uniq
+    end
+
+    # Get the constants defined in a list of binaries
+    # @param  [Array<String>] binaries
+    #         The binaries containing symbols to be mangled
+    # @return [Array<String>] The constants defined in the binaries
+    def self.constants(binaries)
+      all_symbols = run_nm(binaries, '-gU')
+      consts = all_symbols.select { |const| const[/ S /] }
+      consts = consts.reject { |const| const[/_OBJC_/] }
+      consts = consts.map! { |const| const.gsub(/^.* _/, '') }
+      consts = consts.uniq
+
+      other_consts = all_symbols.select { |const| const[/ T /] }
+      other_consts = other_consts.map! { |const| const.gsub(/^.* _/, '') }
+      other_consts = other_consts.uniq
+
+      consts + other_consts
+    end
+
+    # Get the category selectors defined in a list of binaries
+    # @note   Selectors on classes which are being mangled will not be mangled
+    # @param  [Array<String>] binaries
+    #         The binaries containing symbols to be mangled
+    # @param  [Array<String>] classes
+    #         The classes which are being mangled
+    # @return [Array<String>] The category selectors defined in the binaries
+    def self.category_selectors(binaries, classes)
+      symbols = run_nm(binaries, '-U')
+      selectors = symbols.select { |selector| selector[/ t [-|+]\[[^ ]*\([^ ]*\) [^ ]*\]/] }
+      selectors = selectors.reject do |selector|
+        class_name = selector[/[-|+]\[(.*?)\(/m, 1]
+        classes.include? class_name
+      end
+      selectors = selectors.map { |selector| selector[/[^ ]*\]\z/][0...-1] }
+      selectors = selectors.map { |selector| selector.split(':').first }
+      selectors.uniq
+    end
+
+    # Prefix a given list of symbols
+    # @param  [String] prefix
+    #         The prefix to prepend
+    # @param  [Array<String>] symbols
+    #         The symbols to prefix
+    def self.prefix_symbols(prefix, symbols)
+      symbols.map do |symbol|
+        "#{symbol}=#{prefix}#{symbol}"
+      end
+    end
+
+    # Prefix a given list of selectors
+    # @param  [String] prefix
+    #         The prefix to use
+    # @param  [Array<String>] selectors
+    #         The selectors to prefix
+    def self.prefix_selectors(prefix, selectors)
+      selectors_to_prefix = selectors
+      defines = []
+
+      property_setters = selectors.select { |selector| selector[/\Aset[A-Z]/] }
+      property_setters.each do |property_setter|
+        property_getter = selectors.find do |selector|
+          upper_getter = property_setter[3..-1]
+          lower_getter = upper_getter[0, 1].downcase + upper_getter[1..-1]
+          selector == upper_getter || selector == lower_getter
+        end
+        next if property_getter.nil?
+
+        selectors_to_prefix.reject! { |selector| selector == property_setter }
+        selectors_to_prefix.reject! { |selector| selector == property_getter }
+
+        defines << "#{property_setter}=set#{prefix}#{property_getter}"
+        defines << "#{property_getter}=#{prefix}#{property_getter}"
+      end
+
+      defines += prefix_symbols(prefix, selectors_to_prefix)
+      defines
+    end
+
+    def self.run_nm(binaries, flags)
+      `nm #{flags} #{binaries.join(' ')}`.split("\n")
+    end
+  end
+end

data/lib/cocoapods_mangle/gem_version.rb

@@ -0,0 +1,4 @@
+module CocoapodsMangle
+  NAME = 'cocoapods-mangle'
+  VERSION = '1.0.0'
+end

data/lib/cocoapods_mangle/hooks.rb

@@ -0,0 +1,15 @@
+require 'cocoapods_mangle/context'
+require 'cocoapods_mangle/post_install'
+
+module CocoapodsMangle
+  # Registers for CocoaPods plugin hooks
+  module Hooks
+    Pod::HooksManager.register(CocoapodsMangle::NAME, :post_install) do |installer_context, options|
+      context = Context.new(installer_context, options)
+      post_install = CocoapodsMangle::PostInstall.new(context)
+      Pod::UI.titled_section 'Updating mangling' do
+        post_install.run!
+      end
+    end
+  end
+end

data/lib/cocoapods_mangle/post_install.rb

@@ -0,0 +1,23 @@
+require 'cocoapods'
+require 'cocoapods_mangle/config'
+
+module CocoapodsMangle
+  # Runs the post mangling post install action
+  class PostInstall
+    # @param [CocoapodsMangle::Context] context The context for mangling.
+    def initialize(context)
+      @context = context
+    end
+
+    # Run the post install action
+    def run!
+      config.update_mangling! if config.needs_update?
+      config.update_pod_xcconfigs_for_mangling!
+    end
+
+    # @return [CocoapodsMangle::Config] The mangling config object
+    def config
+      @config ||= CocoapodsMangle::Config.new(@context)
+    end
+  end
+end

data/lib/cocoapods_mangle.rb

@@ -0,0 +1,2 @@
+require 'cocoapods_mangle/gem_version'
+require 'cocoapods_mangle/hooks'

data/lib/cocoapods_plugin.rb

@@ -0,0 +1 @@
+require 'cocoapods_mangle'

data/spec/integration/integration_spec.rb

@@ -0,0 +1,95 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require 'tmpdir'
+require 'cocoapods_mangle/config'
+
+def defines_from_xcconfig(xcconfig_path)
+  xcconfig = Xcodeproj::Config.new(File.new(xcconfig_path)).to_hash
+  xcconfig[CocoapodsMangle::Config::MANGLING_DEFINES_XCCONFIG_KEY].split(' ')
+end
+
+def build_sample
+  `xcodebuild -workspace "Mangle Integration.xcworkspace" -scheme "Mangle Integration" -sdk iphonesimulator build`
+  $?.success?
+end
+
+RSpec.shared_examples 'mangling integration' do
+  it 'installs and mangles all expected symbols' do
+    Dir.chdir project_dir
+
+    # Calling the command directly here rather than through the Ruby API
+    # because the CocoaPods Ruby API seems to keep some state between installs
+    `bundle exec pod install`
+    pod_install_success = $?.success?
+    expect(pod_install_success).to be_truthy
+
+    xcconfig_path = File.join(project_dir, "Pods/Target Support Files/#{CocoapodsMangle::NAME}.xcconfig")
+    expect(defines_from_xcconfig(xcconfig_path)).to match_array(expected_defines)
+    expect(build_sample).to be_truthy
+  end
+end
+
+describe CocoapodsMangle do
+  let(:tmp_dir) { Dir.mktmpdir }
+  let(:project_dir) { File.join(tmp_dir, 'project') }
+  let(:pod_dir) { File.join(tmp_dir, 'pod') }
+
+  before(:each) do
+    fixtures_dir = File.expand_path("#{File.dirname(__FILE__)}/../fixtures")
+    FileUtils.copy_entry(File.join(fixtures_dir, 'project'), project_dir)
+    FileUtils.copy_entry(File.join(fixtures_dir, 'pod'), pod_dir)
+    File.open(File.join(project_dir, 'Podfile'), 'w') do |podfile|
+      podfile.write(podfile_contents)
+    end
+  end
+
+  context 'without frameworks' do
+    let(:podfile_contents) do
+      <<~PODFILE
+        platform :ios, '8.0'
+        plugin 'cocoapods-mangle'
+        target 'Mangle Integration' do
+          pod 'ManglePod', path: '../pod'
+        end
+      PODFILE
+    end
+    let(:expected_defines) do
+      %w[
+        PodsDummy_ManglePod=Mangle_Integration_PodsDummy_ManglePod
+        CPMObject=Mangle_Integration_CPMObject
+        CPMConstant=Mangle_Integration_CPMConstant
+        CPMStringFromIntegerFunction=Mangle_Integration_CPMStringFromIntegerFunction
+        cpm_doSomethingWithoutParams=Mangle_Integration_cpm_doSomethingWithoutParams
+        cpm_doSomethingWithParam=Mangle_Integration_cpm_doSomethingWithParam
+      ]
+    end
+
+    include_examples 'mangling integration'
+  end
+
+  context 'with frameworks' do
+    let(:podfile_contents) do
+      <<~PODFILE
+        platform :ios, '8.0'
+        use_frameworks!
+        plugin 'cocoapods-mangle'
+        target 'Mangle Integration' do
+          pod 'ManglePod', path: '../pod'
+        end
+      PODFILE
+    end
+    let(:expected_defines) do
+      %w[
+        ManglePodVersionNumber=Mangle_Integration_ManglePodVersionNumber
+        ManglePodVersionString=Mangle_Integration_ManglePodVersionString
+        PodsDummy_ManglePod=Mangle_Integration_PodsDummy_ManglePod
+        CPMObject=Mangle_Integration_CPMObject
+        CPMConstant=Mangle_Integration_CPMConstant
+        CPMStringFromIntegerFunction=Mangle_Integration_CPMStringFromIntegerFunction
+        cpm_doSomethingWithoutParams=Mangle_Integration_cpm_doSomethingWithoutParams
+        cpm_doSomethingWithParam=Mangle_Integration_cpm_doSomethingWithParam
+      ]
+    end
+
+    include_examples 'mangling integration'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'cocoapods'
+
+module Pod
+  # Overrides logging so it does not pollute the tests
+  #
+  module UI
+    class << self
+      def puts(message = '') end
+
+      def print(message) end
+    end
+  end
+end

data/spec/unit/builder_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require 'cocoapods_mangle/builder'
+
+describe CocoapodsMangle::Builder do
+  let(:pods_project_path) { 'path/to/Pods.xcodeproj' }
+  let(:pod_target_labels) { %w[Pod-A Pod-B] }
+  let(:subject) { CocoapodsMangle::Builder.new(pods_project_path, pod_target_labels) }
+
+  context '.build!' do
+    before do
+      allow(FileUtils).to receive(:remove_dir).with(CocoapodsMangle::Builder::BUILD_DIR, true)
+    end
+
+    it 'builds' do
+      expect(FileUtils).to receive(:remove_dir).with(CocoapodsMangle::Builder::BUILD_DIR, true)
+      expect(subject).to receive(:build_target).with('Pod-A')
+      expect(subject).to receive(:build_target).with('Pod-B')
+      subject.build!
+    end
+  end
+
+  context '.binaries_to_mangle' do
+    let(:static_binaries) { %w[path/to/staticA.a path/to/staticB.a] }
+    let(:frameworks) { %w[path/to/FrameworkA.framework path/to/FrameworkB.framework] }
+    let(:framework_binaries) do
+      frameworks.map { |path| "#{path}/#{File.basename(path, '.framework')}" }
+    end
+    before do
+      allow(Dir).to receive(:glob)
+        .with("#{CocoapodsMangle::Builder::BUILT_PRODUCTS_DIR}/**/*.a")
+        .and_return(static_binaries + ['path/to/libPods-A.a'])
+      allow(Dir).to receive(:glob)
+        .with("#{CocoapodsMangle::Builder::BUILT_PRODUCTS_DIR}/**/*.framework")
+        .and_return(frameworks + ['path/to/Pods_A.framework'])
+    end
+
+    it 'gives the static and framework binaries' do
+      binaries = static_binaries + framework_binaries
+      expect(subject.binaries_to_mangle).to match_array(binaries)
+    end
+  end
+end

data/spec/unit/config_spec.rb

@@ -0,0 +1,121 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require 'cocoapods_mangle/config'
+
+describe CocoapodsMangle::Config do
+  let(:context) do
+    instance_double('Mangle context',
+                    xcconfig_path: 'path/to/mangle.xcconfig',
+                    pod_target_labels: ['Pods-A'],
+                    pods_project_path: 'path/to/Pods.xcodeproj',
+                    mangle_prefix: 'prefix_',
+                    specs_checksum: 'checksum',
+                    pod_xcconfig_paths: ['path/to/A.xcconfig', 'path/to/B.xcconfig'])
+  end
+  let(:subject) do
+    CocoapodsMangle::Config.new(context)
+  end
+
+  context '.update_mangling!' do
+    let(:xcconfig_file) { double('config') }
+    let(:binaries_to_mangle) { ['binary_A', 'binary_B'] }
+    let(:mangling_defines) { ['A=B', 'C=D'] }
+    let(:builder) { double('builder') }
+
+    before do
+      allow(CocoapodsMangle::Builder).to receive(:new).with(context.pods_project_path, context.pod_target_labels).and_return(builder)
+      allow(builder).to receive(:build!)
+      allow(builder).to receive(:binaries_to_mangle).and_return(binaries_to_mangle)
+      allow(CocoapodsMangle::Defines).to receive(:mangling_defines).with(context.mangle_prefix, binaries_to_mangle).and_return(mangling_defines)
+      allow(File).to receive(:open).and_call_original
+      allow(File).to receive(:open).with(context.xcconfig_path, 'w').and_yield(xcconfig_file)
+    end
+
+    it 'updates mangling' do
+      expect(builder).to receive(:build!)
+      xcconfig_contents = ''
+      expect(xcconfig_file).to receive(:write) { |arg| xcconfig_contents = arg }
+
+      subject.update_mangling!
+
+      expect(xcconfig_contents).to include("MANGLING_DEFINES = #{mangling_defines.join(" ")}")
+      expect(xcconfig_contents).to include('MANGLED_SPECS_CHECKSUM = checksum')
+    end
+  end
+
+  context '.needs_update?' do
+    let(:xcconfig_file) { double('config file') }
+    let(:xcodeproj_config) { double('xcodeproj config') }
+    let(:xcconfig_specs_checksum) { 'checksum' }
+
+    before do
+      allow(File).to receive(:exist?).and_call_original
+      allow(File).to receive(:exist?).with(context.xcconfig_path).and_return(true)
+      allow(File).to receive(:new).and_call_original
+      allow(File).to receive(:new).with(context.xcconfig_path).and_return(xcconfig_file)
+      allow(Xcodeproj::Config).to receive(:new).with(xcconfig_file).and_return(xcodeproj_config)
+      allow(xcodeproj_config).to receive(:to_hash).and_return('MANGLING_DEFINES' => 'A=B C=D',
+                                                              'MANGLED_SPECS_CHECKSUM' => "#{xcconfig_specs_checksum}")
+    end
+
+    context 'equal checksums' do
+      before do
+        allow(context).to receive(:specs_checksum).and_return('checksum')
+      end
+
+      it 'does not need an update' do
+        expect(subject.needs_update?).to eq(false)
+      end
+    end
+
+    context 'different checksums' do
+      before do
+        allow(context).to receive(:specs_checksum).and_return('other_checksum')
+      end
+
+      it 'needs an update' do
+        expect(subject.needs_update?).to eq(true)
+      end
+    end
+
+    context 'no config' do
+      before do
+        allow(File).to receive(:exist?).with(context.xcconfig_path).and_return(false)
+      end
+
+      it 'needs an update' do
+        expect(subject.needs_update?).to eq(true)
+      end
+    end
+  end
+
+  context '.update_pod_xcconfigs_for_mangling!' do
+    it 'updates each unique config' do
+      context.pod_xcconfig_paths.each do |pod_xcconfig|
+        expect(subject).to receive(:update_pod_xcconfig_for_mangling!).with(pod_xcconfig)
+      end
+      subject.update_pod_xcconfigs_for_mangling!
+    end
+  end
+
+  context '.update_pod_xcconfig_for_mangling!' do
+    let(:pod_xcconfig_path) { '/path/to/pod.xcconfig' }
+    let(:pod_xcconfig_content) { "GCC_PREPROCESSOR_DEFINITIONS = A=B\nKEY = VALUE" }
+    let(:pod_xcconfig_file) { double('pod_config') }
+
+    before do
+      allow(File).to receive(:readlines).and_call_original
+      allow(File).to receive(:readlines).and_return(pod_xcconfig_content.split("\n"))
+      allow(File).to receive(:read).and_call_original
+      allow(File).to receive(:read).and_return(pod_xcconfig_content)
+      allow(File).to receive(:open).and_call_original
+      allow(File).to receive(:open).with(pod_xcconfig_path, 'w').and_yield(pod_xcconfig_file)
+    end
+
+    it 'updates the pod config' do
+      pod_xcconfig_contents = ''
+      expect(pod_xcconfig_file).to receive(:write) { |arg| pod_xcconfig_contents = arg }
+      subject.update_pod_xcconfig_for_mangling!(pod_xcconfig_path)
+      expect(pod_xcconfig_contents).to eq("#include \"#{context.xcconfig_path}\"\nGCC_PREPROCESSOR_DEFINITIONS = A=B $(MANGLING_DEFINES)\nKEY = VALUE")
+    end
+  end
+end

data/spec/unit/context_spec.rb

@@ -0,0 +1,129 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require 'cocoapods_mangle/context'
+
+describe CocoapodsMangle::Context do
+  let(:umbrella_targets) do
+    [
+      instance_double('umbrella target A', cocoapods_target_label: 'Pods-A', user_targets: [instance_double('target A', name: 'A')]),
+      instance_double('umbrella target B', cocoapods_target_label: 'Pods-B', user_targets: [instance_double('target B', name: 'B')]),
+      instance_double('umbrella target C', cocoapods_target_label: 'Pods-C', user_targets: [instance_double('target C', name: 'C')])
+    ]
+  end
+  let(:installer_context) { instance_double('installer context', umbrella_targets: umbrella_targets) }
+  let(:options) { {} }
+  let(:subject) { CocoapodsMangle::Context.new(installer_context, options) }
+
+  context '.xcconfig_path' do
+    before do
+      allow(installer_context).to receive_message_chain(:sandbox, :target_support_files_root).and_return( Pathname.new('/support_files') )
+      allow(installer_context).to receive_message_chain(:sandbox, :root, :parent).and_return( Pathname.new('/parent') )
+    end
+
+    context 'No options' do
+      it 'gives the default xcconfig path' do
+        expect(subject.xcconfig_path).to eq("/support_files/#{CocoapodsMangle::NAME}.xcconfig")
+      end
+    end
+
+    context 'User provided xcconfig path' do
+      let(:options) { { xcconfig_path: 'path/to/mangle.xcconfig' } }
+      it 'gives the user xcconfig path, relative to the project' do
+        expect(subject.xcconfig_path).to eq("/parent/#{options[:xcconfig_path]}")
+      end
+    end
+  end
+
+  context '.mangle_prefix' do
+    context 'No options' do
+      before do
+        allow(umbrella_targets.first).to receive_message_chain(:user_project, :path).and_return('path/to/Project.xcodeproj')
+      end
+
+      it 'gives the project name as the prefix' do
+        expect(subject.mangle_prefix).to eq('Project_')
+      end
+    end
+
+    context 'No options with space in project name' do
+      before do
+        allow(umbrella_targets.first).to receive_message_chain(:user_project, :path).and_return('path/to/Project Name.xcodeproj')
+      end
+
+      it 'gives the project name with underscores as the prefix' do
+        expect(subject.mangle_prefix).to eq('Project_Name_')
+      end
+    end
+
+    context 'User provided prefix' do
+      let(:options) { { mangle_prefix: 'Prefix_' } }
+
+      it 'gives the user prefix' do
+        expect(subject.mangle_prefix).to eq(options[:mangle_prefix])
+      end
+    end
+  end
+
+  context '.pods_project_path' do
+    let(:pods_project) { instance_double('pods project', path: 'path/to/Pods.xcodeproj') }
+
+    before do
+      allow(installer_context).to receive(:pods_project).and_return(pods_project)
+    end
+
+    it 'gives the project path' do
+      expect(subject.pods_project_path).to eq(pods_project.path)
+    end
+  end
+
+  context '.pod_target_labels' do
+    context 'No options' do
+      it 'gives all targets' do
+        expect(subject.pod_target_labels).to eq(['Pods-A', 'Pods-B', 'Pods-C'])
+      end
+    end
+
+    context 'With targets' do
+      let(:options) { { targets: ['A', 'B'] } }
+      it 'gives only requested targets' do
+        expect(subject.pod_target_labels).to eq(['Pods-A', 'Pods-B'])
+      end
+    end
+  end
+
+  context '.pod_xcconfig_paths' do
+    let(:pods_project) { instance_double('pods project', path: 'path/to/Pods.xcodeproj') }
+    let(:pod_target) { double('target') }
+    let(:debug_build_configuration) { double('debug') }
+    let(:release_build_configuration) { double('release') }
+
+    before do
+      allow(installer_context).to receive(:pods_project).and_return(pods_project)
+      allow(pods_project).to receive(:targets).and_return([pod_target])
+      build_configurations = [debug_build_configuration, release_build_configuration]
+      allow(pod_target).to receive(:build_configurations).and_return(build_configurations)
+      build_configurations.each do |config|
+        allow(config).to receive_message_chain(:base_configuration_reference, :real_path).and_return('path/to/pod.xcconfig')
+      end
+    end
+
+    it 'gives the pod xcconfigs' do
+      expect(subject.pod_xcconfig_paths).to eq(['path/to/pod.xcconfig'])
+    end
+  end
+
+  context '.specs_checksum' do
+    let(:gem_summary) { "#{CocoapodsMangle::NAME}=#{CocoapodsMangle::VERSION}" }
+    let(:spec_A) { instance_double('Spec A', checksum: 'checksum_A') }
+    let(:spec_B) { instance_double('Spec B', checksum: 'checksum_B') }
+    let(:options) { { targets: ['A'] } }
+
+    before do
+      allow(umbrella_targets.first).to receive(:specs).and_return([spec_A, spec_B])
+    end
+
+    it 'gives the checksum' do
+      summary = "#{gem_summary},checksum_A,checksum_B"
+      expect(subject.specs_checksum).to eq(Digest::SHA1.hexdigest(summary))
+    end
+  end
+end

data/spec/unit/defines_spec.rb

@@ -0,0 +1,109 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require 'cocoapods_mangle/defines'
+
+describe CocoapodsMangle::Defines do
+  let(:non_global_defined_symbols) do
+    File.read("#{File.dirname(__FILE__)}/../fixtures/symbols/non_global_defined_symbols.txt").split("\n")
+  end
+  let(:all_defined_symbols) do
+    File.read("#{File.dirname(__FILE__)}/../fixtures/symbols/all_defined_symbols.txt").split("\n")
+  end
+  let(:defines) { CocoapodsMangle::Defines.mangling_defines('Prefix_', ['A.a', 'B.a']) }
+
+  before do
+    allow(CocoapodsMangle::Defines).to receive(:run_nm).with(['A.a', 'B.a'], '-gU').and_return(non_global_defined_symbols)
+    allow(CocoapodsMangle::Defines).to receive(:run_nm).with(['A.a', 'B.a'], '-U').and_return(all_defined_symbols)
+  end
+
+  context 'Class mangling' do
+    let(:expected_classes) do
+      %w[
+        PINDataTaskOperation
+        PINProgressiveImage
+        PodsDummy_PINRemoteImage
+        PINRemoteImageCallbacks
+        PINRemoteImageCategoryManager
+        PINRemoteImageDownloadTask
+        PINRemoteImageManager
+        PINTaskQOS
+        PINRemoteImageManagerResult
+        PINRemoteImageProcessorTask
+        PINRemoteImageTask
+        PINRemoteLock
+        PINURLSessionManager
+        FLAnimatedImage
+        FLWeakProxy
+        FLAnimatedImageView
+      ]
+    end
+
+    it 'should mangle the classes' do
+      expected_classes.each do |class_name|
+        expect(defines).to include("#{class_name}=Prefix_#{class_name}")
+      end
+    end
+  end
+
+  context 'Constant mangling' do
+    let(:expected_constants) do
+      %w[
+        PINRemoteImageManagerErrorDomain
+        PINImageJPEGRepresentation
+        PINImagePNGRepresentation
+        pin_UIImageOrientationFromImageSource
+        dataTaskPriorityWithImageManagerPriority
+        operationPriorityWithImageManagerPriority
+        kFLAnimatedImageDelayTimeIntervalMinimum
+      ]
+    end
+
+    it 'should mangle the constants' do
+      expected_constants.each do |const|
+        expect(defines).to include("#{const}=Prefix_#{const}")
+      end
+    end
+  end
+
+  context 'Category selector mangling' do
+    let(:expected_non_property_selectors) do
+      %w[
+        pin_cancelImageDownload
+        pin_clearImages
+        pin_downloadImageOperationUUID
+        pin_ignoreGIFs
+        pin_setDownloadImageOperationUUID
+        pin_setImageFromURL
+        pin_setImageFromURLs
+        pin_setPlaceholderWithImage
+        pin_updateUIWithImage
+        pin_isGIF
+        pin_decodedImageWithCGImageRef
+        pin_decodedImageWithData
+        pin_addOperationWithQueuePriority
+      ]
+    end
+    let(:mangled_class_non_property_selectors) do
+      %w[
+        logStringFromBlock
+        setLogBlock
+      ]
+    end
+
+    it 'should mangle the category selectors' do
+      expected_non_property_selectors.each do |sel|
+        expect(defines).to include("#{sel}=Prefix_#{sel}")
+      end
+    end
+
+    it 'should not mangle the category selectors on mangled classes' do
+      mangled_class_non_property_selectors.each do |sel|
+        expect(defines).not_to include("#{sel}=Prefix_#{sel}")
+      end
+    end
+
+    it 'should mangle the category property selectors' do
+      expect(defines).to include('pin_updateWithProgress=Prefix_pin_updateWithProgress')
+      expect(defines).to include('setPin_updateWithProgress=setPrefix_pin_updateWithProgress')
+    end
+  end
+end

data/spec/unit/hooks_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require 'cocoapods_mangle/hooks'
+
+def trigger_post_install(installer_context, options)
+  post_install_hooks = Pod::HooksManager.registrations[:post_install]
+  hook = post_install_hooks.find { |h| h.plugin_name == CocoapodsMangle::NAME }
+  hook.block.call(installer_context, options)
+end
+
+describe CocoapodsMangle::Hooks do
+  let(:installer_context) { instance_double('installer context') }
+  let(:options) { double('options') }
+  let(:mangle_context) { instance_double('installer context') }
+  let(:post_install) { double('post install') }
+
+  before do
+    allow(CocoapodsMangle::Context).to receive(:new).with(installer_context, options).and_return(mangle_context)
+    allow(CocoapodsMangle::PostInstall).to receive(:new).with(mangle_context).and_return(post_install)
+    allow(post_install).to receive(:run!)
+  end
+
+  context 'post install' do
+    it 'runs the post install action' do
+      expect(post_install).to receive(:run!)
+      trigger_post_install(installer_context, options)
+    end
+  end
+end

data/spec/unit/post_install_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path('../../spec_helper', __FILE__)
+require 'cocoapods_mangle/post_install'
+
+describe CocoapodsMangle::PostInstall do
+  let(:context) do 
+    instance_double('Mangle context')
+  end
+  let(:subject) do
+    CocoapodsMangle::PostInstall.new(context)
+  end
+  let(:config) { double('config') }
+
+  context '.run!' do
+    let(:specs_checksum) { 'checksum' }
+
+    before do
+      allow(subject).to receive(:config).and_return(config)
+      allow(context).to receive(:specs_checksum).and_return(specs_checksum)
+    end
+
+    it 'updates mangling and pod xcconfigs' do
+      allow(config).to receive(:needs_update?).and_return(true)
+      expect(config).to receive(:update_mangling!)
+      expect(config).to receive(:update_pod_xcconfigs_for_mangling!)
+
+      subject.run!
+    end
+
+    it 'updates pod xcconfigs only' do
+      allow(config).to receive(:needs_update?).and_return(false)
+      expect(config).not_to receive(:update_mangling!)
+      expect(config).to receive(:update_pod_xcconfigs_for_mangling!)
+
+      subject.run!
+    end
+  end
+
+  context '.config' do
+    let(:specs_checksum) { 'checksum' }
+
+    before do
+      allow(subject).to receive(:specs_checksum).and_return(specs_checksum)
+      allow(CocoapodsMangle::Config).to receive(:new).with(context).and_return(config)
+    end
+
+    it 'creates a config' do
+      expect(CocoapodsMangle::Config).to receive(:new).with(context)
+      expect(subject.config).to eq(config)
+    end
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: cocoapods-mangle
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- James Treanor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cocoapods
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Mangling your dependencies symbols allows more than one copy of a dependency
+  to exist without errors. This plugin mangles your dependecies to make this possible
+email:
+- james@intercom.io
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- CHANGELOG.md
+files:
+- CHANGELOG.md
+- README.md
+- lib/cocoapods_mangle.rb
+- lib/cocoapods_mangle/builder.rb
+- lib/cocoapods_mangle/config.rb
+- lib/cocoapods_mangle/context.rb
+- lib/cocoapods_mangle/defines.rb
+- lib/cocoapods_mangle/gem_version.rb
+- lib/cocoapods_mangle/hooks.rb
+- lib/cocoapods_mangle/post_install.rb
+- lib/cocoapods_plugin.rb
+- spec/integration/integration_spec.rb
+- spec/spec_helper.rb
+- spec/unit/builder_spec.rb
+- spec/unit/config_spec.rb
+- spec/unit/context_spec.rb
+- spec/unit/defines_spec.rb
+- spec/unit/hooks_spec.rb
+- spec/unit/post_install_spec.rb
+homepage: https://github.com/intercom/cocoapods-mangle
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.1
+signing_key: 
+specification_version: 4
+summary: A CocoaPods plugin which mangles the symbols of your dependencies
+test_files:
+- spec/integration/integration_spec.rb
+- spec/spec_helper.rb
+- spec/unit/builder_spec.rb
+- spec/unit/config_spec.rb
+- spec/unit/context_spec.rb
+- spec/unit/defines_spec.rb
+- spec/unit/hooks_spec.rb
+- spec/unit/post_install_spec.rb