cocoapods-packager-qcloud 1.5.1

data/lib/cocoapods-packager/framework.rb

@@ -0,0 +1,66 @@
+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
+
+    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
+
+    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,265 @@
+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(
+          File.basename(@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 = {}
+        spec_path = @path
+        if spec_path
+          options[:podspec] = spec_path
+        else
+          options[:path] = '.'
+        end
+        puts "path is #{@path}"
+        options[:subspecs] = subspecs if subspecs
+        dependencies = @allLocalDependencies
+        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)
+
+          if not dependencies.nil?
+            for dep in dependencies
+              pod dep.name , path:dep.path
+              puts "pod #{dep.name} #{dep.path}"
+            end
+          else
+            puts "depencies is nil"
+          end
+          target('packager') do
+             if spec_path
+               if subspecs
+                 subspecs.each do |subspec|
+                   pod spec_name + '/' + subspec, :podspec => spec_path
+                 end
+               else
+                 pod spec_name, :podspec => spec_path
+               end
+             elsif subspecs
+               subspecs.each do |subspec|
+                 pod spec_name + '/' + subspec, :path => '.'
+               end
+             else
+               pod spec_name, :path => '.'
+             end
+          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? || !Pathname.new(path).exist?
+        @path = Pathname(path).realpath.to_path
+        puts "path is #{@path}"
+
+        if Pathname.new(path).directory?
+          help! path + ': is a directory.'
+          return
+        end
+
+        unless ['.podspec', '.json'].include? Pathname.new(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
+
+      def install_dynamic_pod(dynamic_sandbox, static_sandbox, static_installer)
+        # 1 Create a dynamic target for only the spec pod.
+        dynamic_target = build_dynamic_target(dynamic_sandbox, static_installer)
+
+        # 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. Copy the supporting files for the dynamic framework from the static sandbox.
+        copy_dynamic_supporting_files(static_sandbox, dynamic_target, dynamic_sandbox)
+
+        # 5. Update the file accecssors.
+        dynamic_target = update_file_accessors(dynamic_target, dynamic_sandbox)
+
+        # 6. Create the file references.
+        install_file_references(dynamic_sandbox, [dynamic_target], project)
+
+        # 7. Install the target.
+        install_library(dynamic_sandbox, dynamic_target)
+
+        # 9. Write the actual Xcodeproject to the dynamic sandbox.
+        write_pod_project(project, dynamic_sandbox)
+      end
+
+      def build_dynamic_target(dynamic_sandbox, static_installer)
+        spec_targets = static_installer.pod_targets.select do |target|
+          target.name == @spec.name
+        end
+        static_target = spec_targets[0]
+
+        dynamic_target = Pod::PodTarget.new(static_target.specs, static_target.target_definitions, dynamic_sandbox)
+        dynamic_target.host_requires_frameworks = true
+        dynamic_target.user_build_configurations = static_target.user_build_configurations
+        dynamic_target
+      end
+
+      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)
+
+        dynamic_sandbox.project = pods_project
+        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 copy_dynamic_supporting_files(_static_sandbox, dynamic_target, _dynamic_sandbox)
+        support_dir = Pathname.new(dynamic_target.support_files_dir.to_s.chomp("/#{dynamic_target.name}"))
+        support_dir.mkdir
+      end
+
+      def update_file_accessors(dynamic_target, dynamic_sandbox)
+        pod_root = dynamic_sandbox.pod_dir(dynamic_target.root_spec.name)
+
+        path_list = Sandbox::PathList.new(pod_root)
+        file_accessors = dynamic_target.specs.map do |spec|
+          Sandbox::FileAccessor.new(path_list, spec.consumer(dynamic_target.platform))
+        end
+
+        dynamic_target.file_accessors = file_accessors
+        dynamic_target
+      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)
+        return if dynamic_target.target_definitions.flat_map(&:dependencies).empty?
+        target_installer = Pod::Installer::Xcode::PodsProjectGenerator::PodTargetInstaller.new(dynamic_sandbox, dynamic_target)
+        target_installer.install!
+
+        # Installs System Frameworks
+        dynamic_target.file_accessors.each do |file_accessor|
+          file_accessor.spec_consumer.frameworks.each do |framework|
+            if dynamic_target.should_build?
+              dynamic_target.native_target.add_system_framework(framework)
+            end
+          end
+
+          file_accessor.spec_consumer.libraries.each do |library|
+            if dynamic_target.should_build?
+              dynamic_target.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,35 @@
+module Symbols
+  def symbols_from_library(library)
+    syms = `nm -gU #{library}`.split("\n")
+    result = classes_from_symbols(syms)
+    result += constants_from_symbols(syms)
+
+    result.reject { |e| e == 'llvm.cmdline' || e == 'llvm.embedded.module' }
+  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