cocoapods-packager-m 1.6.1 → 1.6.2

data/lib/cocoapods-packager/mangle.rb

@@ -1,32 +0,0 @@
-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

@@ -1,252 +0,0 @@
-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 = {}
-        if path
-          options[:podspec] = path
-        else
-          options[:path] = '.'
-        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
-            if path
-              if subspecs
-                subspecs.each do |subspec|
-                  pod spec_name + '/' + subspec, :podspec => path
-                end
-              else
-                pod spec_name, :podspec => 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 = 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

@@ -1,63 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

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

@@ -1,15 +0,0 @@
-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_packager.rb

@@ -1,5 +0,0 @@
-module Pod
-  module Packager
-    VERSION = '1.6.1'.freeze
-  end
-end

data/lib/cocoapods_plugin.rb

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

data/lib/pod/command/package.rb

@@ -1,165 +0,0 @@
-require 'tmpdir'
-module Pod
-  class Command
-    class Package < 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.'],
-          ['--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 dependant ' \
-            'pods from (defaults to https://github.com/CocoaPods/Specs.git)']
-        ]
-      end
-
-      def initialize(argv)
-        @embedded = argv.flag?('embedded')
-        @force = argv.flag?('force')
-        @library = argv.flag?('library')
-        @dynamic = argv.flag?('dynamic')
-        @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
-        @spec = spec_with_path(@name)
-        @spec = spec_with_name(@name) unless @spec
-        @skip_i = argv.flag?('skip_i')
-        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
-      end
-
-      def run
-        if @path.nil? || @spec.nil?
-          help! 'Unable to find a podspec with path or name.'
-          return
-        end
-
-        target_dir, work_dir = create_working_directory
-        return if target_dir.nil?
-        build_package
-
-        `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)
-        end
-
-        begin
-          perform_build(platform, static_sandbox, dynamic_sandbox)
-
-        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)
-        newspec = builder.spec_metadata
-
-        @spec.available_platforms.each do |platform|
-          build_in_sandbox(platform)
-
-          newspec += builder.spec_platform(platform)
-        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
-        `cp #{@path} #{work_dir}`
-        Dir.chdir(work_dir)
-
-        [target_dir, work_dir]
-      end
-
-      def perform_build(platform, static_sandbox, dynamic_sandbox)
-        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(
-          @source_dir,
-          static_sandbox_root,
-          dynamic_sandbox_root,
-          static_sandbox.public_headers.root,
-          @spec,
-          @embedded,
-          @mangle,
-          @dynamic,
-          @config,
-          @bundle_identifier,
-          @exclude_deps,
-          @skip_i
-        )
-
-        builder.build(platform, @library)
-
-        return unless @embedded
-        builder.link_embedded_resources
-      end
-    end
-  end
-end