cocoapods 0.5.1 → 0.6.0.rc1

data/lib/cocoapods/installer/user_project_integrator.rb

@@ -0,0 +1,162 @@
+require 'xcodeproj/workspace'
+require 'xcodeproj/project'
+
+module Pod
+  class Installer
+
+    class UserProjectIntegrator
+      include Pod::Config::Mixin
+
+      def initialize(podfile)
+        @podfile = podfile
+      end
+
+      def integrate!
+        create_workspace!
+
+        # Only need to write out the user's project if any of the target
+        # integrators actually did some work.
+        target_integrators.map(&:integrate!)
+      end
+
+      def workspace_path
+        @podfile.workspace || raise(Informative, "Could not automatically select an Xcode workspace. " \
+                                                 "Specify one in your Podfile.")
+      end
+
+      def pods_project_path
+        config.project_root + "Pods/Pods.xcodeproj"
+      end
+
+      def target_integrators
+        @target_integrators ||= @podfile.target_definitions.values.map do |definition|
+          TargetIntegrator.new(definition) unless definition.empty?
+        end.compact
+      end
+
+      def user_project_paths
+        @podfile.target_definitions.values.map do |td|
+          next if td.empty?
+          td.user_project.path #|| raise(Informative, "Could not resolve the Xcode project in which the " \
+                               #                      "`#{td.name}' target should be integrated.")
+        end.compact
+      end
+
+      def create_workspace!
+        workspace = Xcodeproj::Workspace.new_from_xcworkspace(workspace_path)
+        [pods_project_path, *user_project_paths].each do |project_path|
+          project_path = project_path.relative_path_from(config.project_root).to_s
+          workspace << project_path unless workspace.include?(project_path)
+        end
+        unless workspace_path.exist? || config.silent?
+          puts "[!] From now on use `#{workspace_path.basename}'."
+        end
+        workspace.save_as(workspace_path)
+      end
+
+      class TargetIntegrator
+        attr_reader :target_definition
+
+        def initialize(target_definition)
+          @target_definition = target_definition
+        end
+
+        def inspect
+          "#<#{self.class} for target `#{@target_definition.label}'>"
+        end
+
+        def integrate!
+          return if targets.empty?
+
+          unless Config.instance.silent?
+            # TODO let's just use ActiveSupport.
+            plural = targets.size > 1
+            puts "-> Integrating `#{@target_definition.lib_name}' into target#{'s' if plural} " \
+                 "`#{targets.map(&:name).join(', ')}' of Xcode project `#{user_project_path.basename}'.".green
+          end
+
+          add_xcconfig_base_configuration
+          add_pods_library
+          add_copy_resources_script_phase
+          user_project.save_as(@target_definition.user_project.path)
+        end
+
+        def user_project_path
+          if path = @target_definition.user_project.path
+            unless path.exist?
+              raise Informative, "The Xcode project `#{path}' does not exist."
+            end
+            path
+          else
+            raise Informative, "Could not automatically select an Xcode project.\n" \
+                               "Specify one in your Podfile like so:\n\n" \
+                               "  xcodeproj 'path/to/XcodeProject'"
+          end
+        end
+
+        def user_project
+          @user_project ||= Xcodeproj::Project.new(user_project_path)
+        end
+
+        # This returns a list of the targets from the user’s project to which
+        # this Pods static library should be linked. If no explicit target was
+        # specified, then the first encountered target is assumed.
+        #
+        # In addition this will only return targets that do **not** already
+        # have the Pods library in their frameworks build phase.
+        #
+        # @return [Array<PBXNativeTarget>]  Returns the list of targets that
+        #                                   the Pods lib should be linked with.
+        def targets
+          @targets ||= begin
+          if link_with = @target_definition.link_with
+            # Find explicitly linked targets.
+            user_project.targets.select do |target|
+              link_with.include? target.name
+            end
+          elsif @target_definition.name != :default
+            # Find the target with the matching name.
+            target = user_project.targets.find { |target| target.name == @target_definition.name.to_s }
+            raise Informative, "Unable to find a target named `#{@target_definition.name.to_s}'" unless target
+            [target]
+          else
+            # Default to the first, which in a simple project is probably an app target.
+            [user_project.targets.first]
+          end.reject do |target|
+              # Reject any target that already has this Pods library in one of its frameworks build phases
+              target.frameworks_build_phases.any? do |phase|
+                phase.files.any? { |file| file.name == @target_definition.lib_name }
+              end
+            end
+          end
+        end
+
+        def add_xcconfig_base_configuration
+          xcconfig = user_project.files.new('path' => @target_definition.xcconfig_relative_path)
+          targets.each do |target|
+            target.build_configurations.each do |config|
+              config.base_configuration = xcconfig
+            end
+          end
+        end
+
+        def add_pods_library
+          pods_library = user_project.group("Frameworks").files.new_static_library(@target_definition.label)
+          targets.each do |target|
+            target.frameworks_build_phases.each { |build_phase| build_phase << pods_library }
+          end
+        end
+
+        def add_copy_resources_script_phase
+          targets.each do |target|
+            phase = target.shell_script_build_phases.new
+            phase.name = 'Copy Pods Resources'
+            phase.shell_script = %{"#{@target_definition.copy_resources_script_relative_path}"\n}
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/cocoapods/local_pod.rb

@@ -0,0 +1,240 @@
+module Pod
+  class LocalPod
+    attr_reader :top_specification, :specifications
+    attr_reader :sandbox
+
+    def initialize(specification, sandbox, platform)
+      @top_specification, @sandbox = specification.top_level_parent, sandbox
+      @top_specification.activate_platform(platform)
+      @specifications = [] << specification
+    end
+
+    def self.from_podspec(podspec, sandbox, platform)
+      new(Specification.from_file(podspec), sandbox, platform)
+    end
+
+    # Method to add the specifications sharing the same top level
+    # parent. With this information the local pod can determine the
+    # paths to clean and avoid duplication in file processing.
+    # Adding specifications is idempotent.
+    def add_specification(spec)
+      raise Informative, "[Local Pod] Attempt to add a specification from another pod" unless spec.top_level_parent == top_specification
+      spec.activate_platform(platform)
+      @specifications << spec unless @specifications.include?(spec)
+    end
+
+    def root
+      @sandbox.root + top_specification.name
+    end
+
+    def subspecs
+      specifications.reject{|s| s.parent.nil? }
+    end
+
+    def to_s
+      result = top_specification.to_s
+      result << " [LOCAL]" if top_specification.local?
+      result
+    end
+
+    def name
+      top_specification.name
+    end
+
+    def platform
+      top_specification.active_platform
+    end
+
+    # Installation methods
+
+    def create
+      root.mkpath unless exists?
+    end
+
+    def exists?
+      root.exist?
+    end
+
+    def chdir(&block)
+      create
+      Dir.chdir(root, &block)
+    end
+
+    def implode
+      root.rmtree if exists?
+    end
+
+    # It deletes all the files identified by clean_files, then it removes
+    # all the empty folders or symlinks.
+    def clean
+      clean_files.each { |path| FileUtils.rm_rf(path) }
+
+      # Get all the directories. Then sort them from the longest
+      # to the shortest, so a directory will be empty if its
+      # subdirs where empty. We need to delete the symlinks because
+      # it might prevent a bundle from being deleted
+      dirs = Dir.glob(root + "**/*", File::FNM_DOTMATCH)
+      dirs = dirs.reject { |d| d.end_with?('.', '..') || !File.directory?(d) }.sort_by(&:length).reverse
+      dirs.each    { |d| FileUtils.rm_rf(d) if File.symlink?(d) || (Dir.entries(d) == %w[ . .. ]) }
+    end
+
+    # File attributes
+
+    def prefix_header_file
+      root + top_specification.prefix_header_file if top_specification.prefix_header_file
+    end
+
+    def source_files(relative = true)
+      chained_expanded_paths(:source_files, :glob => '*.{h,m,mm,c,cpp}', :relative_to_sandbox => relative)
+    end
+
+    def header_files
+      source_files.select { |f| f.extname == '.h' }
+    end
+
+    def resources(relative = true)
+      chained_expanded_paths(:resources, :relative_to_sandbox => relative)
+    end
+
+    def clean_files
+      all_files = Dir.glob(root + "**/*", File::FNM_DOTMATCH).map { |f| root + f }.reject { |p| p.directory? }
+      all_files - used_files
+    end
+
+    def used_files
+      source_files(false) + resources(false) + preserve_paths + [ readme_file, license_file, prefix_header_file ]
+    end
+
+    # TODO: implement case insensitive search
+    def preserve_paths
+      chained_expanded_paths(:preserve_paths) + expanded_paths(%w[ *.podspec notice* NOTICE* CREDITS* ])
+    end
+
+    def readme_file
+      expanded_paths(%w[ README{*,.*} readme{*,.*} ]).first
+    end
+
+    def license_file
+      if top_specification.license && top_specification.license[:file]
+        root + top_specification.license[:file]
+      else
+        expanded_paths(%w[ LICENSE{*,.*} licence{*,.*} ]).first
+      end
+    end
+
+    def license_text
+      if (license_hash = top_specification.license)
+        if (result = license_hash[:text])
+          result
+        elsif license_file
+          result = IO.read(license_file)
+        end
+      end
+    end
+
+    def xcconfig
+      specifications.map { |s| s.xcconfig }.reduce(:merge)
+    end
+
+    # Method used by documentation generator. It return the source files
+    # of all the specs.
+    def all_specs_public_header_files
+      #TODO: merge with #221
+      specs = top_specification.recursive_subspecs << top_specification
+      specs.map { |s| expanded_paths(s.source_files, :glob => '*.{h}') }.compact.flatten.select { |f| f.extname == '.h' }.uniq
+    end
+
+    # Integration methods
+
+    def link_headers
+      copy_header_mappings.each do |namespaced_path, files|
+        @sandbox.add_header_files(namespaced_path, files)
+      end
+    end
+
+    def add_to_target(target)
+      sources_files_by_specification.each do | spec, files |
+        files.each do |file|
+          # TODO: Xcodeproj::Project::Object::PBXNativeTarget#add_source_file is quite slow
+          # The issus appears to be related to the find call in line 107.
+          target.add_source_file(file, nil, spec.compiler_flags.strip)
+        end
+      end
+    end
+
+    def requires_arc?
+      top_specification.requires_arc
+    end
+
+    private
+
+    def implementation_files
+      source_files.select { |f| f.extname != '.h' }
+    end
+
+    def relative_root
+      root.relative_path_from(@sandbox.root)
+    end
+
+    # TODO this is being overriden in the RestKit 0.9.4 spec, need to do
+    # something with that, and this method also still exists in Specification.
+    #
+    # This is not overriden anymore in specification refactor and the code
+    # Pod::Specification#copy_header_mapping can be moved here.
+    def copy_header_mappings
+      search_path_headers = header_files - headers_excluded_from_search_paths
+      search_path_headers.inject({}) do |mappings, from|
+        from_without_prefix = from.relative_path_from(relative_root)
+        to = top_specification.header_dir + top_specification.copy_header_mapping(from_without_prefix)
+        (mappings[to.dirname] ||= []) << from
+        mappings
+      end
+    end
+
+    # returns an hash where the source_files are groupped by specification.
+    # If the same file is required by two specifications the one at the
+    # higher level in the inheritance chain wins.
+    def sources_files_by_specification
+      files_by_spec   = {}
+      processed_files = []
+      specifications.sort_by { |s| s.name.length }.each do |spec|
+        files = []
+        expanded_paths(spec.source_files, :glob => '*.{h,m,mm,c,cpp}', :relative_to_sandbox => true).each do | file |
+          files << file unless processed_files.include?(file)
+        end
+        files_by_spec[spec] = files
+        processed_files    += files
+      end
+      files_by_spec
+    end
+
+    def headers_excluded_from_search_paths
+      chained_expanded_paths(:exclude_header_search_paths, :glob => '*.h', :relative_to_sandbox => true)
+    end
+
+    def chained_expanded_paths(accessor, options = {})
+      specifications.map { |s| expanded_paths(s.send(accessor), options) }.compact.flatten.uniq
+    end
+
+    def expanded_paths(patterns, options = {})
+      raise Informative, "[Local Pod] Attempt to resolve paths for non existent pod." unless exists?
+
+      patterns = [ patterns ] if patterns.is_a? String
+      patterns.map do |pattern|
+        pattern = root + pattern
+
+        if pattern.directory? && options[:glob]
+          pattern += options[:glob]
+        end
+
+        pattern.glob.map do |file|
+          if options[:relative_to_sandbox]
+            file.relative_path_from(@sandbox.root)
+          else
+            file
+          end
+        end
+      end.flatten
+    end
+  end
+end

data/lib/cocoapods/platform.rb

@@ -1,42 +1,65 @@
 module Pod
   class Platform
-    attr_reader :options
-    
-    def initialize(symbolic_name, options = {})
+    def self.ios
+      new :ios
+    end
+
+    def self.osx
+      new :osx
+    end
+
+    attr_reader :deployment_target
+
+    def initialize(symbolic_name = nil, deployment_target = nil)
       @symbolic_name = symbolic_name
-      @options = options
+      if deployment_target
+        version = deployment_target.is_a?(Hash) ? deployment_target[:deployment_target] : deployment_target # backwards compatibility from 0.6
+        @deployment_target = Pod::Version.create(version)
+      end
     end
-    
+
     def name
       @symbolic_name
     end
-    
+
+    def deployment_target= (version)
+      @deployment_target = Pod::Version.create(version)
+    end
+
     def ==(other_platform_or_symbolic_name)
       if other_platform_or_symbolic_name.is_a?(Symbol)
         @symbolic_name == other_platform_or_symbolic_name
       else
-        self == (other_platform_or_symbolic_name.name)
+        self.name == (other_platform_or_symbolic_name.name) && self.deployment_target == other_platform_or_symbolic_name.deployment_target
       end
     end
-    
+
+    def supports?(other)
+      return true if @symbolic_name.nil? || other.nil?
+      os_check      = @symbolic_name == other.name
+      version_check = (deployment_target.nil? || other.deployment_target.nil? || deployment_target >= other.deployment_target)
+      os_check && version_check
+    end
+
     def to_s
-      name.to_s
+      case @symbolic_name
+      when :ios
+        'iOS' + (deployment_target ? " #{deployment_target}" : '')
+      when :osx
+        'OS X' + (deployment_target ? " #{deployment_target}" : '')
+      else
+        'iOS - OS X'
+      end
     end
-    
+
     def to_sym
       name
     end
-    
+
     def nil?
       name.nil?
     end
-    
-    def deployment_target
-      if (opt = options[:deployment_target])
-        Pod::Version.new(opt)
-      end
-    end
-    
+
     def requires_legacy_ios_archs?
       return unless deployment_target
       (name == :ios) && (deployment_target < Pod::Version.new("4.3"))