cocoapods-tt 0.0.1

data/lib/cocoapods-tt/native/generator/info_plist_file.rb

@@ -0,0 +1,128 @@
+module Pod
+  module Generator
+    # Generates Info.plist files. A Info.plist file is generated for each
+    # Pod and for each Pod target definition, that requires to be built as
+    # framework. It states public attributes.
+    #
+    class InfoPlistFile
+      # @return [String] version The version to use for when generating this Info.plist file.
+      #
+      attr_reader :version
+
+      # @return [Platform] The platform to use for when generating this Info.plist file.
+      #
+      attr_reader :platform
+
+      # @return [Symbol] the CFBundlePackageType of the target this Info.plist
+      #         file is for.
+      #
+      attr_reader :bundle_package_type
+
+      # @return [Hash] any additional entries to include in this Info.plist
+      #
+      attr_reader :additional_entries
+
+      # Initialize a new instance
+      #
+      # @param  [String] version @see #version
+      # @param  [Platform] platform @see #platform
+      # @param  [Symbol] bundle_package_type @see #bundle_package_type
+      # @param  [Hash] additional_entries @see #additional_entries
+      #
+      def initialize(version, platform, bundle_package_type = :fmwk, additional_entries = {})
+        @version = version
+        @platform = platform
+        @bundle_package_type = bundle_package_type
+        @additional_entries = additional_entries
+      end
+
+      # Generates and saves the Info.plist to the given path.
+      #
+      # @param  [Pathname] path
+      #         the path where the prefix header should be stored.
+      #
+      # @return [void]
+      #
+      def save_as(path)
+        contents = generate
+        path.open('w') do |f|
+          f.write(contents)
+        end
+      end
+
+      # Generates the contents of the Info.plist
+      #
+      # @return [String]
+      #
+      def generate
+        to_plist(info)
+      end
+
+      private
+
+      def header
+        <<-PLIST
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+        PLIST
+      end
+
+      def footer
+        <<-PLIST
+</plist>
+        PLIST
+      end
+
+      def to_plist(root)
+        serialize(root, header) << footer
+      end
+
+      def serialize(value, output, indentation = 0)
+        indent = ' ' * indentation
+        case value
+        when Array
+          output << indent << "<array>\n"
+          value.each { |v| serialize(v, output, indentation + 2) }
+          output << indent << "</array>\n"
+        when Hash
+          output << indent << "<dict>\n"
+          value.to_a.sort_by(&:first).each do |key, v|
+            output << indent << '  ' << "<key>#{key}</key>\n"
+            serialize(v, output, indentation + 2)
+          end
+          output << indent << "</dict>\n"
+        when String
+          output << indent << "<string>#{value}</string>\n"
+        when true
+          output << indent << "<true/>\n"
+        when false
+          output << indent << "<false/>\n"
+        end
+        output
+      end
+
+      def info
+        info = {
+          'CFBundleIdentifier' => '${PRODUCT_BUNDLE_IDENTIFIER}',
+          'CFBundleInfoDictionaryVersion' => '6.0',
+          'CFBundleName' => '${PRODUCT_NAME}',
+          'CFBundlePackageType' => bundle_package_type.to_s.upcase,
+          'CFBundleShortVersionString' => version,
+          'CFBundleSignature' => '????',
+          'CFBundleVersion' => '${CURRENT_PROJECT_VERSION}',
+          'NSPrincipalClass' => '',
+          'CFBundleDevelopmentRegion' => 'en',
+        }
+
+        info['CFBundleExecutable'] = '${EXECUTABLE_NAME}' if bundle_package_type != :bndl
+        info['CFBundleVersion'] = '1' if bundle_package_type == :bndl
+        info['NSPrincipalClass'] = 'NSApplication' if bundle_package_type == :appl && platform == :osx
+
+        info.merge!(additional_entries)
+
+        info
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/generator/module_map.rb

@@ -0,0 +1,99 @@
+module Pod
+  module Generator
+    # Generates LLVM module map files. A module map file is generated for each
+    # Pod and for each Pod target definition that is built as a framework. It
+    # specifies a different umbrella header than usual to avoid name conflicts
+    # with existing headers of the podspec.
+    #
+    class ModuleMap
+      # @return [PodTarget, AggregateTarget] the target the module map is generated for.
+      #
+      attr_reader :target
+
+      attr_reader :headers
+
+      Header = Struct.new(:path, :umbrella, :private, :textual, :exclude, :size, :mtime) do
+        alias_method :private?, :private
+        def to_s
+          [
+            (:private if private?),
+            (:textual if textual),
+            (:umbrella if umbrella),
+            (:exclude if exclude),
+            'header',
+            %("#{path.to_s.gsub('"', '\"')}"),
+            attrs,
+          ].compact.join(' ')
+        end
+
+        def attrs
+          attrs = {
+            'size' => size,
+            'mtime' => mtime,
+          }.reject { |_k, v| v.nil? }
+          return nil if attrs.empty?
+          attrs.to_s
+        end
+      end
+
+      # Initialize a new instance
+      #
+      # @param  [PodTarget, AggregateTarget] target @see target
+      #
+      def initialize(target)
+        @target = target
+        @headers = [
+          Header.new(target.umbrella_header_path.basename, true),
+        ]
+      end
+
+      # Generates and saves the Info.plist to the given path.
+      #
+      # @param  [Pathname] path
+      #         the path where the prefix header should be stored.
+      #
+      # @return [void]
+      #
+      def save_as(path)
+        contents = generate
+        path.open('w') do |f|
+          f.write(contents)
+        end
+      end
+
+      # Generates the contents of the module.modulemap file.
+      #
+      # @return [String]
+      #
+      def generate
+        <<-MODULE_MAP.strip_heredoc
+#{module_specifier_prefix}module #{target.product_module_name}#{module_declaration_attributes} {
+  #{headers.join("\n  ")}
+
+  export *
+  module * { export * }
+}
+        MODULE_MAP
+      end
+
+      private
+
+      # The prefix to `module` to prepend in the module map.
+      # Ensures that only framework targets have `framework` prepended.
+      #
+      def module_specifier_prefix
+        if target.build_as_framework?
+          'framework '
+        else
+          ''
+        end
+      end
+
+      # The suffix attributes to `module`.
+      #
+      def module_declaration_attributes
+        ''
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/generator/prefix_header.rb

@@ -0,0 +1,60 @@
+module Pod
+  module Generator
+    # Generates a prefix header file for a Pods library. The prefix header is
+    # generated according to the platform of the target and the pods.
+    #
+    # According to the platform the prefix header imports `UIKit/UIKit.h` or
+    # `Cocoa/Cocoa.h`.
+    #
+    class PrefixHeader < Header
+      # @return [Array<FileAccessor>] The file accessors for which to generate
+      #         the prefix header.
+      #
+      attr_reader :file_accessors
+
+      # Initialize a new instance
+      #
+      # @param  [Array<FileAccessor>] file_accessors
+      #         @see #file_accessors
+      #
+      # @param  [Platform] platform
+      #         @see Header#platform
+      #
+      def initialize(file_accessors, platform)
+        @file_accessors = file_accessors
+        super platform
+      end
+
+      # Generates the contents of the prefix header according to the platform
+      # and the pods.
+      #
+      # @note   Only unique prefix_header_contents are added to the prefix
+      #         header.
+      #
+      # @return [String]
+      #
+      # @todo   Subspecs can specify prefix header information too.
+      # @todo   Check to see if we have a similar duplication issue with
+      #         file_accessor.prefix_header.
+      #
+      def generate
+        result = super
+
+        unique_prefix_header_contents = file_accessors.map do |file_accessor|
+          file_accessor.spec_consumer.prefix_header_contents
+        end.compact.uniq
+
+        unique_prefix_header_contents.each do |prefix_header_contents|
+          result << prefix_header_contents
+          result << "\n"
+        end
+
+        file_accessors.map(&:prefix_header).compact.uniq.each do |prefix_header|
+          result << Pathname(prefix_header).read
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/generator/script_phase_constants.rb

@@ -0,0 +1,100 @@
+module Pod
+  module Generator
+    module ScriptPhaseConstants
+      DEFAULT_SCRIPT_PHASE_HEADER = <<-SH.strip_heredoc.freeze
+#!/bin/sh
+set -e
+set -u
+set -o pipefail
+
+function on_error {
+  echo "$(realpath -mq "${0}"):$1: error: Unexpected failure"
+}
+trap 'on_error $LINENO' ERR
+      SH
+
+      RSYNC_PROTECT_TMP_FILES = <<-SH.strip_heredoc.freeze
+# This protects against multiple targets copying the same framework dependency at the same time. The solution
+# was originally proposed here: https://lists.samba.org/archive/rsync/2008-February/020158.html
+RSYNC_PROTECT_TMP_FILES=(--filter "P .*.??????")
+      SH
+
+      STRIP_INVALID_ARCHITECTURES_METHOD = <<-SH.strip_heredoc.freeze
+# Used as a return value for each invocation of `strip_invalid_archs` function.
+STRIP_BINARY_RETVAL=0
+
+# Strip invalid architectures
+strip_invalid_archs() {
+  binary="$1"
+  warn_missing_arch=${2:-true}
+  # Get architectures for current target binary
+  binary_archs="$(lipo -info "$binary" | rev | cut -d ':' -f1 | awk '{$1=$1;print}' | rev)"
+  # Intersect them with the architectures we are building for
+  intersected_archs="$(echo ${ARCHS[@]} ${binary_archs[@]} | tr ' ' '\\n' | sort | uniq -d)"
+  # If there are no archs supported by this binary then warn the user
+  if [[ -z "$intersected_archs" ]]; then
+    if [[ "$warn_missing_arch" == "true" ]]; then
+      echo "warning: [CP] Vendored binary '$binary' contains architectures ($binary_archs) none of which match the current build architectures ($ARCHS)."
+    fi
+    STRIP_BINARY_RETVAL=1
+    return
+  fi
+  stripped=""
+  for arch in $binary_archs; do
+    if ! [[ "${ARCHS}" == *"$arch"* ]]; then
+      # Strip non-valid architectures in-place
+      lipo -remove "$arch" -output "$binary" "$binary"
+      stripped="$stripped $arch"
+    fi
+  done
+  if [[ "$stripped" ]]; then
+    echo "Stripped $binary of architectures:$stripped"
+  fi
+  STRIP_BINARY_RETVAL=0
+}
+      SH
+
+      INSTALL_DSYM_METHOD = <<-SH.strip_heredoc.freeze
+# Copies and strips a vendored dSYM
+install_dsym() {
+  local source="$1"
+  warn_missing_arch=${2:-true}
+  if [ -r "$source" ]; then
+    # Copy the dSYM into the targets temp dir.
+    echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter \\"- CVS/\\" --filter \\"- .svn/\\" --filter \\"- .git/\\" --filter \\"- .hg/\\" --filter \\"- Headers\\" --filter \\"- PrivateHeaders\\" --filter \\"- Modules\\" \\"${source}\\" \\"${DERIVED_FILES_DIR}\\""
+    rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${source}" "${DERIVED_FILES_DIR}"
+
+    local basename
+    basename="$(basename -s .dSYM "$source")"
+    binary_name="$(ls "$source/Contents/Resources/DWARF")"
+    binary="${DERIVED_FILES_DIR}/${basename}.dSYM/Contents/Resources/DWARF/${binary_name}"
+
+    # Strip invalid architectures from the dSYM.
+    if [[ "$(file "$binary")" == *"Mach-O "*"dSYM companion"* ]]; then
+      strip_invalid_archs "$binary" "$warn_missing_arch"
+    fi
+    if [[ $STRIP_BINARY_RETVAL == 0 ]]; then
+      # Move the stripped file into its final destination.
+      echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter \\"- CVS/\\" --filter \\"- .svn/\\" --filter \\"- .git/\\" --filter \\"- .hg/\\" --filter \\"- Headers\\" --filter \\"- PrivateHeaders\\" --filter \\"- Modules\\" \\"${DERIVED_FILES_DIR}/${basename}.framework.dSYM\\" \\"${DWARF_DSYM_FOLDER_PATH}\\""
+      rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --links --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${DERIVED_FILES_DIR}/${basename}.dSYM" "${DWARF_DSYM_FOLDER_PATH}"
+    else
+      # The dSYM was not stripped at all, in this case touch a fake folder so the input/output paths from Xcode do not reexecute this script because the file is missing.
+      mkdir -p "${DWARF_DSYM_FOLDER_PATH}"
+      touch "${DWARF_DSYM_FOLDER_PATH}/${basename}.dSYM"
+    fi
+  fi
+}
+      SH
+
+      INSTALL_BCSYMBOLMAP_METHOD = <<-SH.strip_heredoc.freeze
+# Copies the bcsymbolmap files of a vendored framework
+install_bcsymbolmap() {
+    local bcsymbolmap_path="$1"
+    local destination="${BUILT_PRODUCTS_DIR}"
+    echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter \"- CVS/\" --filter \"- .svn/\" --filter \"- .git/\" --filter \"- .hg/\" --filter \"- Headers\" --filter \"- PrivateHeaders\" --filter \"- Modules\" \"${bcsymbolmap_path}\" \"${destination}\""
+    rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${bcsymbolmap_path}" "${destination}"
+}
+      SH
+    end
+  end
+end

data/lib/cocoapods-tt/native/generator/umbrella_header.rb

@@ -0,0 +1,46 @@
+module Pod
+  module Generator
+    # Generates an umbrella header file for clang modules, which are used by
+    # dynamic frameworks on iOS 8 and OSX 10.10 under the hood.
+    #
+    # If the target is a +PodTarget+, then the umbrella header is required
+    # to make all public headers in a convenient manner available without the
+    # need to write out header declarations for every library header.
+    #
+    class UmbrellaHeader < Header
+      # @return [Target]
+      #         the target, which provides the product name
+      attr_reader :target
+
+      # Initialize a new instance
+      #
+      # @param  [Target] target
+      #         @see target
+      #
+      def initialize(target)
+        super(target.platform)
+        @target = target
+      end
+
+      # Generates the contents of the umbrella header according to the included
+      # pods.
+      #
+      # @return [String]
+      #
+      def generate
+        result = super
+
+        result << "\n"
+
+        result << <<-eos.strip_heredoc
+        FOUNDATION_EXPORT double #{target.product_module_name}VersionNumber;
+        FOUNDATION_EXPORT const unsigned char #{target.product_module_name}VersionString[];
+        eos
+
+        result << "\n"
+
+        result
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/hooks_manager.rb

@@ -0,0 +1,132 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module Pod
+  # Provides support for the hook system of CocoaPods. The system is designed
+  # especially for plugins. Interested clients can register to notifications by
+  # name.
+  #
+  # The blocks, to prevent compatibility issues, will receive
+  # one and only one argument: a context object. This object should be simple
+  # storage of information (a typed hash). Notifications senders are
+  # responsible to indicate the class of the object associated with their
+  # notification name.
+  #
+  # Context object should not remove attribute accessors to not break
+  # compatibility with the plugins (this promise will be honoured strictly
+  # from CocoaPods 1.0).
+  #
+  module HooksManager
+    # Represents a single registered hook.
+    #
+    class Hook
+      # @return [String]
+      #         The name of the plugin that registered the hook.
+      #
+      attr_reader :plugin_name
+
+      # @return [String]
+      #         The name of the hook.
+      #
+      attr_reader :name
+
+      # @return [Proc]
+      #         The block.
+      #
+      attr_reader :block
+
+      # Initialize a new instance
+      #
+      # @param  [String] name        @see {#name}.
+      #
+      # @param  [String] plugin_name @see {#plugin_name}.
+      #
+      # @param  [Proc]   block       @see {#block}.
+      #
+      def initialize(name, plugin_name, block)
+        raise ArgumentError, 'Missing name' unless name
+        raise ArgumentError, 'Missing plugin_name' unless plugin_name
+        raise ArgumentError, 'Missing block' unless block
+
+        @name = name
+        @plugin_name = plugin_name
+        @block = block
+      end
+    end
+
+    class << self
+      # @return [Hash{Symbol => Array<Hook>}] The list of the hooks that are
+      #         registered for each hook name.
+      #
+      attr_reader :registrations
+
+      # Registers a block for the hook with the given name.
+      #
+      # @param  [String] plugin_name
+      #         The name of the plugin the hook comes from.
+      #
+      # @param  [Symbol] hook_name
+      #         The name of the notification.
+      #
+      # @param  [Proc] block
+      #         The block.
+      #
+      def register(plugin_name, hook_name, &block)
+        @registrations ||= {}
+        @registrations[hook_name] ||= []
+        @registrations[hook_name] << Hook.new(hook_name, plugin_name, block)
+      end
+
+      # Returns all the hooks to run for the given event name
+      # and set of whitelisted plugins
+      #
+      # @see #run
+      #
+      # @return [Array<Hook>] the hooks to run
+      #
+      def hooks_to_run(name, whitelisted_plugins = nil)
+        return [] unless registrations
+        hooks = registrations.fetch(name, [])
+        return hooks unless whitelisted_plugins
+        hooks.select { |hook| whitelisted_plugins.key?(hook.plugin_name) }
+      end
+
+      # Runs all the registered blocks for the hook with the given name.
+      #
+      # @param  [Symbol] name
+      #         The name of the hook.
+      #
+      # @param  [Object] context
+      #         The context object which should be passed to the blocks.
+      #
+      # @param  [Hash<String, Hash>] whitelisted_plugins
+      #         The plugins that should be run, in the form of a hash keyed by
+      #         plugin name, where the values are the custom options that should
+      #         be passed to the hook's block if it supports taking a second
+      #         argument.
+      #
+      def run(name, context, whitelisted_plugins = nil)
+        raise ArgumentError, 'Missing name' unless name
+        raise ArgumentError, 'Missing options' unless context
+
+        hooks = hooks_to_run(name, whitelisted_plugins)
+        return if hooks.empty?
+
+        UI.message "- Running #{name.to_s.tr('_', ' ')} hooks" do
+          hooks.each do |hook|
+            UI.message "- #{hook.plugin_name} from " \
+                        "`#{hook.block.source_location.first}`" do
+              block = hook.block
+              if block.arity > 1
+                user_options = whitelisted_plugins[hook.plugin_name]
+                user_options = user_options.with_indifferent_access if user_options
+                block.call(context, user_options)
+              else
+                block.call(context)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/installer/analyzer/analysis_result.rb

@@ -0,0 +1,87 @@
+module Pod
+  class Installer
+    class Analyzer
+      # A simple container produced after a analysis is completed by the {Analyzer}.
+      #
+      class AnalysisResult
+        # @return [SpecsState] the states of the Podfile specs.
+        #
+        attr_reader :podfile_state
+
+        # @return [Hash{TargetDefinition => Array<Specification>}] the specifications grouped by target.
+        #
+        attr_reader :specs_by_target
+
+        # @return [Hash{Source => Array<Specification>}] the specifications grouped by spec repo source.
+        #
+        attr_reader :specs_by_source
+
+        # @return [Array<Specification>] the specifications of the resolved version of Pods that should be installed.
+        #
+        attr_reader :specifications
+
+        # @return [SpecsState] the states of the {Sandbox} respect the resolved specifications.
+        #
+        attr_reader :sandbox_state
+
+        # @return [Array<AggregateTarget>] The aggregate targets created for each {TargetDefinition} from the {Podfile}.
+        #
+        attr_reader :targets
+
+        # @return [Array<PodTarget>] The pod targets created for all the aggregate targets.
+        #
+        attr_reader :pod_targets
+
+        # @return [PodfileDependencyCache] the cache of all dependencies in the podfile.
+        #
+        attr_reader :podfile_dependency_cache
+
+        def initialize(podfile_state, specs_by_target, specs_by_source, specifications, sandbox_state, targets, pod_targets,
+                       podfile_dependency_cache)
+          @podfile_state = podfile_state
+          @specs_by_target = specs_by_target
+          @specs_by_source = specs_by_source
+          @specifications = specifications
+          @sandbox_state = sandbox_state
+          @targets = targets
+          @pod_targets = pod_targets
+          @podfile_dependency_cache = podfile_dependency_cache
+        end
+
+        # @return [Hash{String=>Symbol}] A hash representing all the user build
+        #         configurations across all integration targets. Each key
+        #         corresponds to the name of a configuration and its value to
+        #         its type (`:debug` or `:release`).
+        #
+        def all_user_build_configurations
+          targets.reduce({}) do |result, target|
+            result.merge(target.user_build_configurations)
+          end
+        end
+
+        # @return [Bool] Whether an installation should be performed or this
+        #         CocoaPods project is already up to date.
+        #
+        def needs_install?
+          podfile_needs_install? || sandbox_needs_install?
+        end
+
+        # @return [Bool] Whether the podfile has changes respect to the lockfile.
+        #
+        def podfile_needs_install?
+          state = podfile_state
+          needing_install = state.added.length + state.changed.length + state.deleted.length
+          needing_install > 0
+        end
+
+        # @return [Bool] Whether the sandbox is in synch with the lockfile.
+        #
+        def sandbox_needs_install?
+          state = sandbox_state
+          needing_install = state.added.length + state.changed.length + state.deleted.length
+          needing_install > 0
+        end
+      end
+    end
+  end
+end