xcocoapods 1.5.3

data/lib/cocoapods/generator/header.rb

@@ -0,0 +1,103 @@
+module Pod
+  module Generator
+    # Generates a header file.
+    #
+    # According to the platform the header imports `UIKit/UIKit.h` or
+    # `Cocoa/Cocoa.h`.
+    #
+    class Header
+      # @return [Symbol] the platform for which the prefix header will be
+      #         generated.
+      #
+      attr_reader :platform
+
+      # @return [Array<String>] The list of the headers to import.
+      #
+      attr_accessor :imports
+
+      # @return [Array<String>] The list of the modules to import.
+      #
+      attr_reader :module_imports
+
+      # Initialize a new instance
+      #
+      # @param  [Symbol] platform
+      #         @see platform
+      #
+      def initialize(platform)
+        @platform = platform
+        @imports = []
+        @module_imports = []
+      end
+
+      # Generates the contents of the header according to the platform.
+      #
+      # @note   If the platform is iOS an import call to `UIKit/UIKit.h` is
+      #         added to the top of the prefix header. For OS X `Cocoa/Cocoa.h`
+      #         is imported.
+      #
+      # @return [String]
+      #
+      def generate
+        result = ''
+        result << "#ifdef __OBJC__\n"
+        result << generate_platform_import_header
+        result << "#else\n"
+        result << "#ifndef FOUNDATION_EXPORT\n"
+        result << "#if defined(__cplusplus)\n"
+        result << "#define FOUNDATION_EXPORT extern \"C\"\n"
+        result << "#else\n"
+        result << "#define FOUNDATION_EXPORT extern\n"
+        result << "#endif\n"
+        result << "#endif\n"
+        result << "#endif\n"
+        result << "\n"
+
+        imports.each do |import|
+          result << %(#import "#{import}"\n)
+        end
+
+        unless module_imports.empty?
+          module_imports.each do |import|
+            result << %(\n@import #{import})
+          end
+          result << "\n"
+        end
+
+        result
+      end
+
+      # Generates and saves the header to the given path.
+      #
+      # @param  [Pathname] path
+      #         The path where the header should be stored.
+      #
+      # @return [void]
+      #
+      def save_as(path)
+        path.open('w') { |header| header.write(generate) }
+      end
+
+      #-----------------------------------------------------------------------#
+
+      protected
+
+      # Generates the contents of the header according to the platform.
+      #
+      # @note   If the platform is iOS an import call to `UIKit/UIKit.h` is
+      #         added to the top of the header. For OS X `Cocoa/Cocoa.h` is
+      #         imported.
+      #
+      # @return [String]
+      #
+      def generate_platform_import_header
+        case platform.name
+        when :ios then "#import <UIKit/UIKit.h>\n"
+        when :tvos then "#import <UIKit/UIKit.h>\n"
+        when :osx then "#import <Cocoa/Cocoa.h>\n"
+        else "#import <Foundation/Foundation.h>\n"
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/generator/info_plist_file.rb

@@ -0,0 +1,116 @@
+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 [Version] 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
+
+      # Initialize a new instance
+      #
+      # @param  [Version] version @see version
+      # @param  [Platform] platform @see platform
+      # @param  [Symbol] bundle_package_type @see bundle_package_type
+      #
+      def initialize(version, platform, bundle_package_type = :fmwk)
+        @version = version
+        @platform = platform
+        @bundle_package_type = bundle_package_type
+      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"
+        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
+      end
+    end
+  end
+end

data/lib/cocoapods/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.requires_frameworks?
+          'framework '
+        else
+          ''
+        end
+      end
+
+      # The suffix attributes to `module`.
+      #
+      def module_declaration_attributes
+        ''
+      end
+    end
+  end
+end

data/lib/cocoapods/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/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/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