cocoapods-packager-xz 1.0.0

data/lib/cocoapods-packager/framework.rb

@@ -0,0 +1,77 @@
+module Framework
+  class Tree
+    attr_reader :headers_path
+    attr_reader :module_map_path
+    attr_reader :resources_path
+    attr_reader :root_path
+    attr_reader :versions_path
+    attr_accessor :fwk_path
+    attr_accessor :name
+    attr_accessor :versions_path
+    def delete_resources
+      Pathname.new(@resources_path).rmtree
+      (Pathname.new(@fwk_path) + Pathname.new('Resources')).delete
+    end
+
+    def initialize(name, platform, embedded)
+      @name = name
+      @platform = platform
+      @embedded = embedded
+    end
+
+    def make
+      make_root
+      make_framework
+      make_headers
+      make_resources
+      make_current_version
+    end
+    
+    def process_static_framework
+        `rm -rf #{@fwk_path}/Headers`
+        `rm -rf #{@fwk_path}/Resources`
+        `rm -rf #{@fwk_path}/#{@name}`
+        `cp -r #{@versions_path}/* #{fwk_path}`
+        `rm -rf #{@fwk_path}/Versions`
+    end
+
+    private
+
+    def make_current_version
+      current_version_path = @versions_path + Pathname.new('../Current')
+      `ln -sf A #{current_version_path}`
+      `ln -sf Versions/Current/Headers #{@fwk_path}/`
+      `ln -sf Versions/Current/Resources #{@fwk_path}/`
+      `ln -sf Versions/Current/#{@name} #{@fwk_path}/`
+    end
+
+    def make_framework
+      @fwk_path = @root_path + Pathname.new(@name + '.framework')
+      @fwk_path.mkdir unless @fwk_path.exist?
+
+      @module_map_path = @fwk_path + Pathname.new('Modules')
+      @versions_path = @fwk_path + Pathname.new('Versions/A')
+    end
+
+
+    def make_headers
+      @headers_path = @versions_path + Pathname.new('Headers')
+      @headers_path.mkpath unless @headers_path.exist?
+    end
+
+    def make_resources
+      @resources_path = @versions_path + Pathname.new('Resources')
+      @resources_path.mkpath unless @resources_path.exist?
+    end
+
+    def make_root
+      @root_path = Pathname.new(@platform)
+
+      if @embedded
+        @root_path += Pathname.new(@name + '.embeddedframework')
+      end
+
+      @root_path.mkpath unless @root_path.exist?
+    end
+  end
+end

data/lib/cocoapods-packager/mangle.rb

@@ -0,0 +1,32 @@
+module Symbols
+  #
+  # performs symbol aliasing
+  #
+  # for each dependency:
+  # 	- determine symbols for classes and global constants
+  # 	- alias each symbol to Pod#{pod_name}_#{symbol}
+  # 	- put defines into `GCC_PREPROCESSOR_DEFINITIONS` for passing to Xcode
+  #
+  def mangle_for_pod_dependencies(pod_name, sandbox_root)
+    pod_libs = Dir.glob("#{sandbox_root}/build/lib*.a").select do |file|
+      file !~ /lib#{pod_name}.a$/
+    end
+
+    dummy_alias = alias_symbol "PodsDummy_#{pod_name}", pod_name
+    all_syms = [dummy_alias]
+
+    pod_libs.each do |pod_lib|
+      syms = Symbols.symbols_from_library(pod_lib)
+      all_syms += syms.map! { |sym| alias_symbol sym, pod_name }
+    end
+
+    "GCC_PREPROCESSOR_DEFINITIONS='$(inherited) #{all_syms.uniq.join(' ')}'"
+  end
+
+  def alias_symbol(sym, pod_name)
+    pod_name = pod_name.tr('-', '_')
+    sym + "=Pod#{pod_name}_" + sym
+  end
+
+  module_function :mangle_for_pod_dependencies, :alias_symbol
+end

data/lib/cocoapods-packager/pod_utils.rb

@@ -0,0 +1,244 @@
+module Pod
+  class Command
+    class Package < Command
+      private
+
+      def build_static_sandbox(dynamic)
+        static_sandbox_root = if dynamic
+                                Pathname.new(config.sandbox_root + '/Static')
+                              else
+                                Pathname.new(config.sandbox_root)
+                              end
+        Sandbox.new(static_sandbox_root)
+      end
+
+      def install_pod(platform_name, sandbox)
+        podfile = podfile_from_spec(
+          @path,
+          @spec.name,
+          platform_name,
+          @spec.deployment_target(platform_name),
+          @subspecs,
+          @spec_sources
+        )
+
+        static_installer = Installer.new(sandbox, podfile)
+        static_installer.install!
+
+        unless static_installer.nil?
+          static_installer.pods_project.targets.each do |target|
+            target.build_configurations.each do |config|
+              config.build_settings['CLANG_MODULES_AUTOLINK'] = 'NO'
+              config.build_settings['GCC_GENERATE_DEBUGGING_SYMBOLS'] = 'NO'
+            end
+          end
+          static_installer.pods_project.save
+        end
+
+        static_installer
+      end
+
+      def podfile_from_spec(path, spec_name, platform_name, deployment_target, subspecs, sources)
+        options = {}
+        if path
+          if @local
+            options[:path] = path
+          else
+            options[:podspec] = path
+          end
+        end
+        options[:subspecs] = subspecs if subspecs
+        Pod::Podfile.new do
+          sources.each { |s| source s }
+          platform(platform_name, deployment_target)
+          pod(spec_name, options)
+
+          install!('cocoapods',
+                   :integrate_targets => false,
+                   :deterministic_uuids => false)
+
+          target('packager') do
+            inherit! :complete
+          end
+        end
+      end
+
+      def binary_only?(spec)
+        deps = spec.dependencies.map { |dep| spec_with_name(dep.name) }
+        [spec, *deps].each do |specification|
+          %w(vendored_frameworks vendored_libraries).each do |attrib|
+            if specification.attributes_hash[attrib]
+              return true
+            end
+          end
+        end
+
+        false
+      end
+
+      def spec_with_name(name)
+        return if name.nil?
+
+        set = Pod::Config.instance.sources_manager.search(Dependency.new(name))
+        return nil if set.nil?
+
+        set.specification.root
+      end
+
+      def spec_with_path(path)
+        return if path.nil?
+        path = Pathname.new(path)
+        path = Pathname.new(Dir.pwd).join(path) unless path.absolute?
+        return unless path.exist?
+
+        @path = path.expand_path
+
+        if @path.directory?
+          help! @path + ': is a directory.'
+          return
+        end
+
+        unless ['.podspec', '.json'].include? @path.extname
+          help! @path + ': is not a podspec.'
+          return
+        end
+
+        Specification.from_file(@path)
+      end
+
+      #----------------------
+      # Dynamic Project Setup
+      #----------------------
+
+      def build_dynamic_sandbox(_static_sandbox, _static_installer)
+        dynamic_sandbox_root = Pathname.new(config.sandbox_root + '/Dynamic')
+        dynamic_sandbox = Sandbox.new(dynamic_sandbox_root)
+
+        dynamic_sandbox
+      end
+
+      # @param [Pod::Sandbox] dynamic_sandbox
+      #
+      # @param [Pod::Sandbox] static_sandbox
+      #
+      # @param [Pod::Installer] static_installer
+      #
+      # @param [Pod::Platform] platform
+      #
+      def install_dynamic_pod(dynamic_sandbox, static_sandbox, static_installer, platform)
+        # 1 Create a dynamic target for only the spec pod.
+        dynamic_target = build_dynamic_target(dynamic_sandbox, static_installer, platform)
+
+        # 2. Build a new xcodeproj in the dynamic_sandbox with only the spec pod as a target.
+        project = prepare_pods_project(dynamic_sandbox, dynamic_target.name, static_installer)
+
+        # 3. Copy the source directory for the dynamic framework from the static sandbox.
+        copy_dynamic_target(static_sandbox, dynamic_target, dynamic_sandbox)
+
+        # 4. Create the file references.
+        install_file_references(dynamic_sandbox, [dynamic_target], project)
+
+        # 5. Install the target.
+        install_library(dynamic_sandbox, dynamic_target, project)
+
+        # 6. Write the actual .xcodeproj to the dynamic sandbox.
+        write_pod_project(project, dynamic_sandbox)
+      end
+
+      # @param [Pod::Installer] static_installer
+      #
+      # @return [Pod::PodTarget]
+      #
+      def build_dynamic_target(dynamic_sandbox, static_installer, platform)
+        spec_targets = static_installer.pod_targets.select do |target|
+          target.name == @spec.name
+        end
+        static_target = spec_targets[0]
+
+        file_accessors = create_file_accessors(static_target, dynamic_sandbox)
+
+        archs = []
+        dynamic_target = Pod::PodTarget.new(dynamic_sandbox, true, static_target.user_build_configurations, archs, platform, static_target.specs, static_target.target_definitions, file_accessors)
+        dynamic_target
+      end
+
+      # @param [Pod::Sandbox] dynamic_sandbox
+      #
+      # @param [String] spec_name
+      #
+      # @param [Pod::Installer] installer
+      #
+      def prepare_pods_project(dynamic_sandbox, spec_name, installer)
+        # Create a new pods project
+        pods_project = Pod::Project.new(dynamic_sandbox.project_path)
+
+        # Update build configurations
+        installer.analysis_result.all_user_build_configurations.each do |name, type|
+          pods_project.add_build_configuration(name, type)
+        end
+
+        # Add the pod group for only the dynamic framework
+        local = dynamic_sandbox.local?(spec_name)
+        path = dynamic_sandbox.pod_dir(spec_name)
+        was_absolute = dynamic_sandbox.local_path_was_absolute?(spec_name)
+        pods_project.add_pod_group(spec_name, path, local, was_absolute)
+        pods_project
+      end
+
+      def copy_dynamic_target(static_sandbox, _dynamic_target, dynamic_sandbox)
+        command = "cp -a #{static_sandbox.root}/#{@spec.name} #{dynamic_sandbox.root}"
+        `#{command}`
+      end
+
+      def create_file_accessors(target, dynamic_sandbox)
+        pod_root = dynamic_sandbox.pod_dir(target.root_spec.name)
+
+        path_list = Sandbox::PathList.new(pod_root)
+        target.specs.map do |spec|
+          Sandbox::FileAccessor.new(path_list, spec.consumer(target.platform))
+        end
+      end
+
+      def install_file_references(dynamic_sandbox, pod_targets, pods_project)
+        installer = Pod::Installer::Xcode::PodsProjectGenerator::FileReferencesInstaller.new(dynamic_sandbox, pod_targets, pods_project)
+        installer.install!
+      end
+
+      def install_library(dynamic_sandbox, dynamic_target, project)
+        return if dynamic_target.target_definitions.flat_map(&:dependencies).empty?
+        target_installer = Pod::Installer::Xcode::PodsProjectGenerator::PodTargetInstaller.new(dynamic_sandbox, project, dynamic_target)
+        result = target_installer.install!
+        native_target = result.native_target
+
+        # Installs System Frameworks
+        if dynamic_target.should_build?
+          dynamic_target.file_accessors.each do |file_accessor|
+            file_accessor.spec_consumer.frameworks.each do |framework|
+              native_target.add_system_framework(framework)
+            end
+            file_accessor.spec_consumer.libraries.each do |library|
+              native_target.add_system_library(library)
+            end
+          end
+        end
+      end
+
+      def write_pod_project(dynamic_project, dynamic_sandbox)
+        UI.message "- Writing Xcode project file to #{UI.path dynamic_sandbox.project_path}" do
+          dynamic_project.pods.remove_from_project if dynamic_project.pods.empty?
+          dynamic_project.development_pods.remove_from_project if dynamic_project.development_pods.empty?
+          dynamic_project.sort(:groups_position => :below)
+          dynamic_project.recreate_user_schemes(false)
+
+          # Edit search paths so that we can find our dependency headers
+          dynamic_project.targets.first.build_configuration_list.build_configurations.each do |config|
+            config.build_settings['HEADER_SEARCH_PATHS'] = "$(inherited) #{Dir.pwd}/Pods/Static/Headers/**"
+            config.build_settings['USER_HEADER_SEARCH_PATHS'] = "$(inherited) #{Dir.pwd}/Pods/Static/Headers/**"
+            config.build_settings['OTHER_LDFLAGS'] = '$(inherited) -ObjC'
+          end
+          dynamic_project.save
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-packager/spec_builder.rb

@@ -0,0 +1,63 @@
+module Pod
+  class SpecBuilder
+    def initialize(spec, source, embedded, dynamic)
+      @spec = spec
+      @source = source.nil? ? '{ :path => \'.\' }' : source
+      @embedded = embedded
+      @dynamic = dynamic
+    end
+
+    def framework_path
+      if @embedded
+        @spec.name + '.embeddedframework' + '/' + @spec.name + '.framework'
+      else
+        @spec.name + '.framework'
+      end
+    end
+
+    def spec_platform(platform)
+      fwk_base = platform.name.to_s + '/' + framework_path
+      spec = <<RB
+  s.#{platform.name}.deployment_target    = '#{platform.deployment_target}'
+  s.#{platform.name}.vendored_framework   = '#{fwk_base}'
+RB
+
+      %w(frameworks weak_frameworks libraries requires_arc xcconfig).each do |attribute|
+        attributes_hash = @spec.attributes_hash[platform.name.to_s]
+        next if attributes_hash.nil?
+        value = attributes_hash[attribute]
+        next if value.nil?
+
+        value = "'#{value}'" if value.class == String
+        spec += "  s.#{platform.name}.#{attribute} = #{value}\n"
+      end
+      spec
+    end
+
+    def spec_metadata
+      spec = spec_header
+      spec
+    end
+
+    def spec_close
+      "end\n"
+    end
+
+    private
+
+    def spec_header
+      spec = "Pod::Spec.new do |s|\n"
+
+      %w(name version summary license authors homepage description social_media_url
+         docset_url documentation_url screenshots frameworks weak_frameworks libraries requires_arc
+         deployment_target xcconfig).each do |attribute|
+        value = @spec.attributes_hash[attribute]
+        next if value.nil?
+        value = value.dump if value.class == String
+        spec += "  s.#{attribute} = #{value}\n"
+      end
+
+      spec + "  s.source = #{@source}\n\n"
+    end
+  end
+end

data/lib/cocoapods-packager/symbols.rb

@@ -0,0 +1,42 @@
+module Symbols
+  def symbols_from_library(library)
+    syms = `nm -defined-only -extern-only #{library}`.split("\n")
+    result = classes_from_symbols(syms)
+    result += constants_from_symbols(syms)
+
+    result.select do |e|
+      case e
+      when 'llvm.cmdline', 'llvm.embedded.module', '__clang_at_available_requires_core_foundation_framework'
+        false
+      else
+        true
+      end
+    end
+  end
+
+  module_function :symbols_from_library
+
+  private
+
+  def classes_from_symbols(syms)
+    classes = syms.select { |klass| klass[/OBJC_CLASS_\$_/] }
+    classes = classes.uniq
+    classes.map! { |klass| klass.gsub(/^.*\$_/, '') }
+  end
+
+  def constants_from_symbols(syms)
+    consts = syms.select { |const| const[/ S /] }
+    consts = consts.select { |const| const !~ /OBJC|\.eh/ }
+    consts = consts.uniq
+    consts = consts.map! { |const| const.gsub(/^.* _/, '') }
+
+    other_consts = syms.select { |const| const[/ T /] }
+    other_consts = other_consts.uniq
+    other_consts = other_consts.map! { |const| const.gsub(/^.* _/, '') }
+
+    consts + other_consts
+  end
+
+  module_function :classes_from_symbols
+  module_function :constants_from_symbols
+end