cocoapods-packagerthk 0.0.1

data/lib/cocoapods-packagerthk/pod_utils.rb

@@ -0,0 +1,245 @@
+module Pod
+  class Command
+    class Packagethk < 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'
+              config.build_settings['EXCLUDED_ARCHS[sdk=iphonesimulator*]'] = 'arm64'
+            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-packagerthk/spec_builder.rb

@@ -0,0 +1,158 @@
+module Pod
+  class SpecBuilder
+    def initialize(spec, source, embedded, dynamic, generate_spec)
+      @spec = spec
+      @source = source.nil? ? '{ :path => \'.\' }' : source
+      @embedded = embedded
+      @dynamic = dynamic
+      @is_generate_spec = generate_spec
+      @generate_spec = ""
+    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_sources_pattern(generate_spec)
+      # 添加Source Pattern
+      spec = <<RB
+
+  if ENV['IS_SOURCE'] || ENV["\#{s.name}_SOURCE"]
+    s.source           = { :git => '#{@spec.attributes_hash['source']['git']}', :commit => "#{@spec.attributes_hash['source']['commit']}" }
+RB
+
+        %w(source_files public_header_files resources frameworks resource_bundles dependencies).each do |attribute|
+        value = @spec.attributes_hash[attribute]
+        next if value.nil?
+          if attribute == 'dependencies'
+            value.each { |key,hashvalue|
+            if hashvalue.empty?
+              spec += "    s.dependency \'#{key}\'\n"
+            else
+              spec += "    s.dependency \'#{key}\', \'#{hashvalue[0]}\'\n"
+            end
+            }
+          else
+              value = value.dump if value.class == String
+              spec += "    s.#{attribute} = #{value}\n"
+          end
+        end
+        #添加subspec (递归添加)
+        @generate_spec = spec
+        @spec.subspecs.each do |subspec|
+          spec_sources_pattern_subpsec(subspec)
+        end
+        spec = @generate_spec
+
+      # 添加Framwork Pattern
+      spec += <<RB
+  else
+    s.source           = { :git => 'git@repo.we.com:iosfeaturelibraries/frameworkrepo.git', :commit => 'xxx'}
+    s.source_files = "\#{s.name}-\#{s.version}/ios/\#{s.name}.framework/Headers/*.h"
+    s.public_header_files = "\#{s.name}-\#{s.version}/ios/\#{s.name}.framework/Headers/*.h"
+    s.ios.vendored_framework = "\#{s.name}-\#{s.version}/ios/\#{s.name}.framework"
+  end
+RB
+      # cur_work_dir = Dir::getwd
+      # Dir.chdir('/Users/joe.cheng/cocoapods-debug')
+      # File.open('debug' + '.podspec', 'w') { |file| file.write(spec) }
+      # Dir.chdir(cur_work_dir)
+      spec
+    end
+
+    def spec_sources_pattern_subpsec(subspec)
+        name = subspec.attributes_hash['name']
+        level = subspec.name.split('/').count
+        curSpec = "s" * (level - 1)
+        space = "  " * (level - 2)
+        nextSpec = curSpec + "s"
+        @generate_spec += space
+        @generate_spec += "    #{curSpec}.subspec \'#{name}\' do |#{nextSpec}|\n"
+        
+        %w(source_files public_header_files resources frameworks resource_bundles dependencies).each do |attribute|
+          value = subspec.attributes_hash[attribute]
+          next if value.nil?
+          @generate_spec += space
+          if attribute == 'dependencies'
+            value.each { |key,hashvalue|
+            if hashvalue.empty?
+              @generate_spec += "      #{nextSpec}.dependency \'#{key}\'\n"
+            else
+              @generate_spec += "      #{nextSpec}.dependency \'#{key}\', \'#{hashvalue[0]}\'\n"
+            end
+            }
+          else
+            value = value.dump if value.class == String
+            @generate_spec += "      #{nextSpec}.#{attribute} = #{value}\n"
+          end
+        end
+
+        if subspec.subspecs.empty?
+          @generate_spec += space
+          @generate_spec += "    end\n"
+        else
+          #添加subspec
+          subspec.subspecs.each do |subsubspec|
+            spec_sources_pattern_subpsec(subsubspec)
+          end
+          @generate_spec += "    end\n"
+        end
+    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
+      if @is_generate_spec
+        source = spec_sources_pattern(true)
+        spec += "#{source}"
+      else
+        spec += "  s.source = #{@source}\n\n"
+      end
+      spec
+    end
+  end
+end

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

data/lib/cocoapods-packagerthk/user_interface/build_failed_report.rb

@@ -0,0 +1,15 @@
+module Pod
+  module UserInterface
+    module BuildFailedReport
+      class << self
+        def report(command, output)
+          <<-EOF
+Build command failed: #{command}
+Output:
+#{output.map { |line| "    #{line}" }.join}
+          EOF
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-packagerthk.rb

@@ -0,0 +1,5 @@
+module Pod
+    module Packagerthk
+      VERSION = '1.0.0'.freeze
+    end
+  end

data/lib/cocoapods_plugin.rb

@@ -0,0 +1,8 @@
+require 'pod/command/packagethk'
+require 'cocoapods-packagerthk/user_interface/build_failed_report'
+require 'cocoapods-packagerthk/builder'
+require 'cocoapods-packagerthk/framework'
+require 'cocoapods-packagerthk/mangle'
+require 'cocoapods-packagerthk/pod_utils'
+require 'cocoapods-packagerthk/spec_builder'
+require 'cocoapods-packagerthk/symbols'

data/lib/pod/command/packagethk.rb

@@ -0,0 +1,198 @@
+require 'tmpdir'
+module Pod
+  class Command
+    class Packagethk < Command
+      self.summary = 'Package a podspec into a static library.'
+      self.arguments = [
+        CLAide::Argument.new('NAME', true),
+        CLAide::Argument.new('SOURCE', false)
+      ]
+
+      def self.options
+        [
+          ['--force',     'Overwrite existing files.'],
+          ['--no-mangle', 'Do not mangle symbols of depedendant Pods.'],
+          ['--embedded',  'Generate embedded frameworks.'],
+          ['--library',   'Generate static libraries.'],
+          ['--dynamic',   'Generate dynamic framework.'],
+          ['--local',     'Use local state rather than published versions.'],
+          ['--bundle-identifier', 'Bundle identifier for dynamic framework'],
+          ['--exclude-deps', 'Exclude symbols from dependencies.'],
+          ['--configuration', 'Build the specified configuration (e.g. Debug). Defaults to Release'],
+          ['--subspecs', 'Only include the given subspecs'],
+          ['--spec-sources=private,https://github.com/CocoaPods/Specs.git', 'The sources to pull dependent ' \
+            'pods from (defaults to https://github.com/CocoaPods/Specs.git)'],
+          ['--generate-spec', 'Generate spec file.']
+        ]
+      end
+
+      def initialize(argv)
+        @embedded = argv.flag?('embedded')
+        @library = argv.flag?('library')
+        @dynamic = argv.flag?('dynamic')
+        @local = argv.flag?('local', false)
+        @package_type = if @embedded
+                          :static_framework
+                        elsif @dynamic
+                          :dynamic_framework
+                        elsif @library
+                          :static_library
+                        else
+                          :static_framework
+                        end
+        @force = argv.flag?('force')
+        @mangle = argv.flag?('mangle', true)
+        @bundle_identifier = argv.option('bundle-identifier', nil)
+        @exclude_deps = argv.flag?('exclude-deps', false)
+        @name = argv.shift_argument
+        @source = argv.shift_argument
+        @spec_sources = argv.option('spec-sources', 'https://github.com/CocoaPods/Specs.git').split(',')
+
+        subspecs = argv.option('subspecs')
+        @subspecs = subspecs.split(',') unless subspecs.nil?
+
+        @config = argv.option('configuration', 'Release')
+
+        @source_dir = Dir.pwd
+        @is_spec_from_path = false
+        @spec = spec_with_path(@name)
+        @is_spec_from_path = true if @spec
+        @spec ||= spec_with_name(@name)
+        @generate_spec = argv.flag?('generate-spec',false)
+        super
+      end
+
+      def validate!
+        super
+        help! 'A podspec name or path is required.' unless @spec
+        help! 'podspec has binary-only depedencies, mangling not possible.' if @mangle && binary_only?(@spec)
+        help! '--bundle-identifier option can only be used for dynamic frameworks' if @bundle_identifier && !@dynamic
+        help! '--exclude-deps option can only be used for static libraries' if @exclude_deps && @dynamic
+        help! '--local option can only be used when a local `.podspec` path is given.' if @local && !@is_spec_from_path
+      end
+
+      def run
+        if @spec.nil?
+          help! "Unable to find a podspec with path or name `#{@name}`."
+          return
+        end
+
+        target_dir, work_dir = create_working_directory
+        # puts work_dir
+        return if target_dir.nil?
+        build_package
+        # 文件迁移FileUtils
+        puts "move files..."
+
+
+        `rm -rf mv #{work_dir}/build/`
+        
+        exist = File::exists?("#{work_dir}/ios/#{@spec.name}.framework/Versions/A/Resources")
+        if exist
+          puts "move Resources..."
+          `rm -rf mv #{work_dir}/ios/#{@spec.name}.framework/Resources`
+          `mv #{work_dir}/ios/#{@spec.name}.framework/Versions/A/Resources  #{work_dir}/ios/#{@spec.name}.framework/`
+        end
+        `rm -rf mv #{work_dir}/ios/#{@spec.name}.framework/Headers`
+        `rm -rf mv #{work_dir}/ios/#{@spec.name}.framework/#{@spec.name}`
+        `mv #{work_dir}/ios/#{@spec.name}.framework/Versions/A/Headers  #{work_dir}/ios/#{@spec.name}.framework/`
+        `mv #{work_dir}/ios/#{@spec.name}.framework/Versions/A/#{@spec.name}  #{work_dir}/ios/#{@spec.name}.framework/`
+        `rm -rf #{work_dir}/ios/#{@spec.name}.framework/Versions`
+        `mv "#{work_dir}" "#{target_dir}"`
+        Dir.chdir(@source_dir)
+      end
+
+      private
+
+      def build_in_sandbox(platform)
+        config.installation_root  = Pathname.new(Dir.pwd)
+        config.sandbox_root       = 'Pods'
+
+        static_sandbox = build_static_sandbox(@dynamic)
+        static_installer = install_pod(platform.name, static_sandbox)
+
+        if @dynamic
+          dynamic_sandbox = build_dynamic_sandbox(static_sandbox, static_installer)
+          install_dynamic_pod(dynamic_sandbox, static_sandbox, static_installer, platform)
+        end
+
+        begin
+          perform_build(platform, static_sandbox, dynamic_sandbox, static_installer)
+        ensure # in case the build fails; see Builder#xcodebuild.
+          Pathname.new(config.sandbox_root).rmtree
+          FileUtils.rm_f('Podfile.lock')
+        end
+      end
+
+      def build_package
+        builder = SpecBuilder.new(@spec, @source, @embedded, @dynamic, @generate_spec)
+        newspec = builder.spec_metadata
+
+        @spec.available_platforms.each do |platform|
+          build_in_sandbox(platform)
+
+          if @generate_spec == false
+            newspec += builder.spec_platform(platform)
+          end
+        end
+
+        newspec += builder.spec_close
+        File.open(@spec.name + '.podspec', 'w') { |file| file.write(newspec) }
+      end
+
+      def create_target_directory
+        target_dir = "#{@source_dir}/#{@spec.name}-#{@spec.version}"
+        if File.exist? target_dir
+          if @force
+            Pathname.new(target_dir).rmtree
+          else
+            UI.puts "Target directory '#{target_dir}' already exists."
+            return nil
+          end
+        end
+        target_dir
+      end
+
+      def create_working_directory
+        target_dir = create_target_directory
+        return if target_dir.nil?
+
+        work_dir = Dir.tmpdir + '/cocoapods-' + Array.new(8) { rand(36).to_s(36) }.join
+        Pathname.new(work_dir).mkdir
+        Dir.chdir(work_dir)
+
+        [target_dir, work_dir]
+      end
+
+      def perform_build(platform, static_sandbox, dynamic_sandbox, static_installer)
+        static_sandbox_root = config.sandbox_root.to_s
+
+        if @dynamic
+          static_sandbox_root = "#{static_sandbox_root}/#{static_sandbox.root.to_s.split('/').last}"
+          dynamic_sandbox_root = "#{config.sandbox_root}/#{dynamic_sandbox.root.to_s.split('/').last}"
+        end
+
+        builder = Pod::Builder.new(
+          platform,
+          static_installer,
+          @source_dir,
+          static_sandbox_root,
+          dynamic_sandbox_root,
+          static_sandbox.public_headers.root,
+          @spec,
+          @embedded,
+          @mangle,
+          @dynamic,
+          @config,
+          @bundle_identifier,
+          @exclude_deps
+        )
+
+        builder.build(@package_type)
+
+        return unless @embedded
+        builder.link_embedded_resources
+      end
+    end
+  end
+end