vendor 0.0.4 → 0.1

data/lib/vendor/vendor_file/library/git.rb

@@ -44,7 +44,11 @@ module Vendor
         # the sources correctly. So instead of using the name, use a hash of
         # the URI
         def cache_path
-          @cache_path ||= File.join(Vendor.library_path, "git", Digest::MD5.hexdigest(uri))
+          File.join(Vendor.library_path, "git", Digest::MD5.hexdigest(uri)) if uri
+        end
+
+        def display_name
+          [ name, "(#{uri}##{tag})" ].join(' ')
         end
 
         private

data/lib/vendor/vendor_file/library/local.rb

@@ -12,9 +12,19 @@ module Vendor
         end
 
         def cache_path
-          File.expand_path(path)
+          expanded_path if path
         end
 
+        def display_name
+          [ name, "(#{expanded_path})" ].join(' ')
+        end
+
+        private
+
+          def expanded_path
+            File.expand_path(path)
+          end
+
       end
 
     end

data/lib/vendor/vendor_file/library/remote.rb

@@ -4,13 +4,145 @@ module Vendor
 
       class Remote < Base
 
-        attr_accessor :version
+        require 'zip/zip'
+
+        attr_accessor :equality
         attr_accessor :sources
 
+        def version
+          @version
+        end
+
+        def version=(value)
+          # Matches (some equality matcher, followed by some spaces, then a version)
+          if value
+            if value.match(/^(\<\=|\>\=|\~\>|\>|\<)?\s*([a-zA-Z0-9\.]+)$/)
+              @equality = $1
+              @version = $2
+            else
+              Vendor.ui.error "Invalid version format '#{value}' for '#{name}'"
+              exit 1
+            end
+          else
+            @equality = nil
+            @version = nil
+          end
+          value
+        end
+
+        def matched_version
+          # If we just have a version, and no equality matcher
+          if version && !equality
+            return version
+          end
+
+          # If we don't have a version, get the latest version
+          # from the remote sources
+          unless version
+            return meta['release']
+          end
+
+          # Try and find a version that matches the lib
+          other_versions = meta['versions'].map { |v| v[0] }
+          found = version_matches_any?(other_versions)
+
+          # Did we actually find something?
+          unless found
+            Vendor.ui.error "Could not find a valid version '#{equality} #{version}' in '#{other_versions}'"
+            exit 1
+          else
+            found
+          end
+        end
+
+        def version_matches_any?(other_versions)
+          # If we have an equality matcher, we need sort through
+          # the versions, and try and find the best match
+          wants = Vendor::Version.new(version)
+
+          # Sort them from the latest versions first
+          versions = other_versions.map{|v| Vendor::Version.create(v) }.sort.reverse
+
+          # We don't want to include pre-releases if the wants version
+          # isn't a pre-release itself. If we're after "2.5.alpha", then
+          # we should be able to include that, however if we're asking for
+          # "2.5", then pre-releases shouldn't be included.
+          unless wants.prerelease?
+            versions = versions.reject { |v| v.prerelease? }
+          end
+
+          # If this a spermy search, we have a slightly different search mechanism. We use the
+          # version segemets to determine if the version is valid. For example, lets say we're
+          # testing to see if "0.1" is a spermy match to "0.1.5.2", we start by getting the
+          # two segments for each:
+          #
+          # [ 0, 1 ]
+          # [ 0, 1, 5, 2 ]
+          #
+          # We chop the second set of segments to be the same lenth as the first one:
+          #
+          # [ 0, 1, 5, 2 ].slice(0, 2) #=. [ 0, 1 ]
+          #
+          # No we just test to see if they are the same! I think this works...
+          if equality == "~>"
+            segments = wants.segments
+            versions.find do |has|
+              segments == has.segments.slice(0, segments.length)
+            end
+          elsif equality
+            versions.find do |has|
+              wants.send(:"#{equality}", has)
+            end
+          else
+            versions.find do |has|
+              wants == has
+            end
+          end
+        end
+
         def download
-          Vendor.ui.info "download #{name} version #{version} from #{sources} to #{cache_path}"
+          # If we haven't already downloaded the vendor
+          unless File.exist?(cache_path)
+            # Download it
+            file = Vendor::API.download(name, matched_version)
+
+            # Unzip the download
+            unzip_file file.path, cache_path
+          end
+        end
+
+        def cache_path
+          File.join(Vendor.library_path, "remote", name, matched_version.to_s)
         end
 
+        def ==(other)
+          other.name == @name && other.version == @version && other.equality == @equality
+        end
+
+        def display_name
+          [ name, matched_version ].compact.join(" ")
+        end
+
+        def description
+          [ @name, @equality, @version ].compact.join(" ")
+        end
+
+        private
+
+          def meta
+            @meta ||= Vendor::API.meta(name)
+          end
+
+          def unzip_file (file, destination)
+            Zip::ZipFile.open(file) { |zip_file|
+              zip_file.each { |f|
+                f_path = File.join(destination, f.name)
+                FileUtils.mkdir_p(File.dirname(f_path))
+                zip_file.extract(f, f_path) unless File.exist?(f_path)
+              }
+            }
+          end
+
       end
 
     end

data/lib/vendor/vendor_file/loader.rb

@@ -6,27 +6,29 @@ module Vendor
       require 'fileutils'
 
       attr_reader :dsl
+      attr_reader :libraries
 
       def initialize
         @dsl = Vendor::VendorFile::DSL.new
+        @libraries = []
       end
 
-      def load(filename)
-        @dsl.instance_eval(File.read(filename), filename)
+      def libraries=(value)
+        @graph = Vendor::VendorFile::DependencyGraph.new(value)
+        @libraries = value
       end
 
-      def download
-        @dsl.libraries.each do |lib|
-          if lib.respond_to?(:sources=)
-            lib.sources = @dsl.sources
-          end
-          lib.download
-        end
+      def load(filename)
+        @dsl.instance_eval(File.read(filename), filename)
+        self.libraries = @dsl.libraries
       end
 
       def install(project)
-        @dsl.libraries.each do |lib|
-          lib.install project
+        unless @graph.version_conflicts?
+          @graph.libraries_to_install.each do |lib|
+            library, targets = lib
+            library.install project, :targets => targets
+          end
         end
       end
 

data/lib/vendor/vendor_spec/builder.rb

@@ -15,14 +15,11 @@ module Vendor
       attr_reader :vendor_spec
 
       def initialize(vendor_spec)
-        loader = Vendor::VendorSpec::Loader.new
-        loader.load vendor_spec
-
         @folder = File.expand_path(File.join(vendor_spec, '..'))
-        @vendor_spec = loader.dsl.vendor_spec
+        @vendor_spec = Vendor::Spec.load vendor_spec
 
-        @name = safe_filename(@vendor_spec[:name])
-        @version = safe_filename(@vendor_spec[:version])
+        @name = safe_filename(@vendor_spec.name)
+        @version = safe_filename(@vendor_spec.version)
         @filename = "#{@name}-#{@version}.vendor"
       end
 
@@ -49,7 +46,7 @@ module Vendor
 
           # Remove files that are within folders with a ".", such as ".bundle"
           # and ".frameworks"
-          copy_files = @vendor_spec[:files].reject { |file| file =~ /\/?[^\/]+\.[^\/]+\// }
+          copy_files = @vendor_spec.files.reject { |file| file =~ /\/?[^\/]+\.[^\/]+\// }
 
           copy_files.each do |file|
             dir = File.dirname(file)

data/lib/vendor/version.rb

@@ -1,5 +1,176 @@
 module Vendor
 
-  VERSION = "0.0.4"
+  class Version
+
+    include Comparable
+
+    VERSION_PATTERN = '[0-9]+(\.[0-9a-zA-Z]+)*' # :nodoc:
+    ANCHORED_VERSION_PATTERN = /\A\s*(#{VERSION_PATTERN})*\s*\z/ # :nodoc:
+
+    ##
+    # A string representation of this Version.
+
+    attr_reader :version
+    alias to_s version
+
+    ##
+    # True if the +version+ string matches Vendor's requirements.
+
+    def self.correct? version
+      version.to_s =~ ANCHORED_VERSION_PATTERN
+    end
+
+    ##
+    # Factory method to create a Version object. Input may be a Version
+    # or a String. Intended to simplify client code.
+    #
+    #   ver1 = Version.create('1.3.17')   # -> (Version object)
+    #   ver2 = Version.create(ver1)       # -> (ver1)
+    #   ver3 = Version.create(nil)        # -> nil
+
+    def self.create input
+      if input === Vendor::Version
+        input
+      elsif input.nil? then
+        nil
+      else
+        new input
+      end
+    end
+
+    ##
+    # Constructs a Version from the +version+ string.  A version string is a
+    # series of digits or ASCII letters separated by dots.
+
+    def initialize version
+      raise ArgumentError, "Malformed version number string #{version}" unless
+        self.class.correct?(version)
+
+      @version = version.to_s
+      @version.strip!
+    end
+
+    ##
+    # Return a new version object where the next to the last revision
+    # number is one greater (e.g., 5.3.1 => 5.4).
+    #
+    # Pre-release (alpha) parts, e.g, 5.3.1.b.2 => 5.4, are ignored.
+
+    def bump
+      segments = self.segments.dup
+      segments.pop while segments.any? { |s| String === s }
+      segments.pop if segments.size > 1
+
+      segments[-1] = segments[-1].succ
+      self.class.new segments.join(".")
+    end
+
+    ##
+    # A Version is only eql? to another version if it's specified to the
+    # same precision. Version "1.0" is not the same as version "1".
+
+    def eql? other
+      self.class === other and @version == other.version
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class} #{version.inspect}>"
+    end
+
+    ##
+    # Dump only the raw version string, not the complete object. It's a
+    # string for backwards (RubyGems 1.3.5 and earlier) compatibility.
+
+    def marshal_dump
+      [version]
+    end
+
+    ##
+    # Load custom marshal format. It's a string for backwards (RubyGems
+    # 1.3.5 and earlier) compatibility.
+
+    def marshal_load array
+      initialize array[0]
+    end
+
+    ##
+    # A version is considered a prerelease if it contains a letter.
+
+    def prerelease?
+      @prerelease ||= @version =~ /[a-zA-Z]/
+    end
+
+    def pretty_print q # :nodoc:
+      q.text "Vendor::Version.new(#{version.inspect})"
+    end
+
+    ##
+    # The release for this version (e.g. 1.2.0.a -> 1.2.0).
+    # Non-prerelease versions return themselves.
+
+    def release
+      return self unless prerelease?
+
+      segments = self.segments.dup
+      segments.pop while segments.any? { |s| String === s }
+      self.class.new segments.join('.')
+    end
+
+    def segments # :nodoc:
+
+      # segments is lazy so it can pick up version values that come from
+      # old marshaled versions, which don't go through marshal_load.
+
+      @segments ||= @version.scan(/[0-9]+|[a-z]+/i).map do |s|
+        /^\d+$/ =~ s ? s.to_i : s
+      end
+    end
+
+    ##
+    # A recommended version for use with a ~> Requirement.
+
+    def spermy_recommendation
+      segments = self.segments.dup
+
+      segments.pop    while segments.any? { |s| String === s }
+      segments.pop    while segments.size > 2
+      segments.push 0 while segments.size < 2
+
+      "~> #{segments.join(".")}"
+    end
+
+    ##
+    # Compares this version with +other+ returning -1, 0, or 1 if the
+    # other version is larger, the same, or smaller than this
+    # one. Attempts to compare to something that's not a
+    # <tt>Vendor::Version</tt> return +nil+.
+
+    def <=> other
+      return unless Vendor::Version === other
+      return 0 if @version == other.version
+
+      lhsegments = segments
+      rhsegments = other.segments
+
+      lhsize = lhsegments.size
+      rhsize = rhsegments.size
+      limit  = (lhsize > rhsize ? lhsize : rhsize) - 1
+
+      i = 0
+
+      while i <= limit
+        lhs, rhs = lhsegments[i] || 0, rhsegments[i] || 0
+        i += 1
+
+        next      if lhs == rhs
+        return -1 if String  === lhs && Numeric === rhs
+        return  1 if Numeric === lhs && String  === rhs
+
+        return lhs <=> rhs
+      end
+
+      return 0
+    end
+  end
 
 end

data/lib/vendor/xcode/project.rb

@@ -4,6 +4,11 @@ module Vendor::XCode
 
   class Project
 
+    # Build settings and the format that they should be stored in
+    BUILD_SETTING_TYPES = {
+      "OTHER_LDFLAGS" => :array
+    }
+
     require 'fileutils'
 
     attr_reader :name
@@ -55,8 +60,13 @@ module Vendor::XCode
       @objects_by_id[id]
     end
 
-    def find_target(name)
-      root_object.targets.find { |x| x.name == name }
+    def find_target(t)
+      # Are we already a target?
+      if t.kind_of?(Vendor::XCode::Proxy::Base)
+        t
+      else
+        root_object.targets.find { |x| x.name == t }
+      end
     end
 
     def find_group(path)
@@ -105,6 +115,8 @@ module Vendor::XCode
       # If we have the group
       if group
 
+        ids_to_remove = []
+
         # Remove the children from the file system
         group.children.each do |child|
           if child.group? # Is it a group?
@@ -120,13 +132,27 @@ module Vendor::XCode
             Vendor.ui.error "Couldn't remove object: #{child}"
           end
 
+          # Remove from the targets (if we can)
+          root_object.targets.each { |t| remove_file_from_target(child, t) }
+
           # Remove the file from the parent
           child.parent.attributes['children'].delete child.id
+
+          # Add the id to the list of stuff to remove. If we do this
+          # during the loop, bad things happen - not sure why.
+          ids_to_remove << child.id
         end
 
         # Remove the group from the parent
         group.parent.attributes['children'].delete group.id
 
+        # Add to the list of stuff to remove
+        ids_to_remove << group.id
+
+        ids_to_remove.each do |id|
+          @objects_by_id.delete id
+        end
+
         # Mark as dirty
         @dirty = true
 
@@ -135,11 +161,101 @@ module Vendor::XCode
       end
     end
 
+    def add_framework(framework, options = {})
+      # Find targets
+      targets = targets_from_options(options)
+      Vendor.ui.debug %{Adding #{framework} to targets "#{targets.map(&:name)}"}
+
+      targets.each do |t|
+        # Does the framework already exist?
+        build_phase = build_phase_for_file("wrapper.framework", t)
+
+        if build_phase
+          # Does a framework already exist?
+          existing_framework = build_phase.files.map(&:file_ref).find do |file|
+            # Some files have names, some done. Framework references
+            # have names...
+            if file.respond_to?(:name)
+              file.name == framework
+            end
+          end
+
+          # If an existing framework was found, don't add it again
+          unless existing_framework
+            add_file :targets => t, :file => "System/Library/Frameworks/#{framework}", :path => "Frameworks", :source_tree => :sdkroot
+          end
+        end
+      end
+    end
+
+    def add_build_setting(name, value, options = {})
+
+      targets_from_options(options).each do |target|
+
+        target.build_configuration_list.build_configurations.each do |config|
+
+          build_settings = config.build_settings
+
+          debug_key = "#{target.name}/#{config.name}".inspect
+
+          # If the build setting already has the key
+          if build_settings.has_key?(name)
+
+            # Is this setting known to have multiple values?
+            if (setting_type = BUILD_SETTING_TYPES[name])
+
+              # If its an array
+              if setting_type == :array
+                # Is it already an array, if so, check to see if
+                # it already exists, and if it doesn't add it.
+                if build_settings[name].kind_of?(Array)
+                  unless build_settings[name].include?
+                    Vendor.ui.debug("  Added build setting (#{name.inspect} = #{value.inspect}) to #{debug_key}")
+
+                    build_settings[name] << value
+                  end
+                else
+                  Vendor.ui.debug("  Added build setting (#{name.inspect} = #{value.inspect}) to #{debug_key}")
+
+                  # Don't add it if the single build value is already there
+                  unless build_settings[name].strip == value.strip
+                    build_settings[name] = [ build_settings[name], value ]
+                  end
+                end
+              end
+
+            else
+              # If its an unknown type, then we should just throw a warning
+              # because we should'nt just change stuff willy, nilly.
+              Vendor.ui.warn("  Build setting #{name.inspect} wanted to change to #{value.inspect}, but it was already #{build_settings[name].inspect} in #{debug_key}")
+            end
+
+          else
+            Vendor.ui.debug("  Added build setting (#{name.inspect} = #{value.inspect}) to #{debug_key}")
+
+            build_settings[name] = value
+          end
+
+        end
+
+      end
+
+      @dirty = true
+
+    end
+
     def add_file(options)
       require_options options, :path, :file, :source_tree
 
-      # Ensure file exists
-      raise StandardError.new("Could not find file `#{options[:file]}`") unless File.exists?(options[:file])
+      # Ensure file exists if we'nre not using the sdk root source tree.
+      # The SDKROOT source tree has a virtual file on the system, so
+      # File.exist checks will always return false.
+      unless options[:source_tree] == :sdkroot
+        raise StandardError.new("Could not find file `#{options[:file]}`") unless File.exists?(options[:file])
+      end
+
+      # Find targets
+      targets = targets_from_options(options)
 
       # Create the group
       group = create_group(options[:path])
@@ -174,6 +290,12 @@ module Vendor::XCode
         attributes['name'] = name
         attributes['path'] = options[:file]
 
+      elsif options[:source_tree] == :sdkroot
+
+        # Set the path and the name of the framework
+        attributes['path'] = options[:file]
+        attributes['sourceTree'] = "SDKROOT"
+
       else
 
         # Could not handle that option
@@ -192,6 +314,11 @@ module Vendor::XCode
       # Add the file id to the groups children
       group.attributes['children'] << file.id
 
+      # Add the file to targets
+      targets.each do |t|
+        add_file_to_target file, t
+      end
+
       # Mark as dirty
       @dirty = true
 
@@ -199,6 +326,50 @@ module Vendor::XCode
       @objects_by_id[file.id] = file
     end
 
+    def remove_file_from_target(file, target)
+
+      # Search through all the build phases for references to the file
+      build_files = []
+      target.build_phases.each do |phase|
+        build_files << phase.files.find_all do |build_file|
+          build_file.attributes['fileRef'] == file.id
+        end
+      end
+
+      # Remove the build files from the references
+      build_files.flatten.each do |build_file|
+        build_file.parent.attributes['files'].delete build_file.id
+        @objects_by_id.delete build_file.id
+      end
+
+    end
+
+    def add_file_to_target(file, target)
+
+      build_phase = build_phase_for_file(file.last_known_file_type, target)
+
+      if build_phase
+
+        Vendor.ui.debug "Adding #{file.attributes} to #{target.name} (build_phase = #{build_phase.class.name})"
+
+        # Add the file to XCode
+        build_file = Vendor::XCode::Proxy::PBXBuildFile.new(:project => self,
+                                                                 :id => Vendor::XCode::Proxy::Base.generate_id,
+                                                         :attributes => { 'fileRef' => file.id })
+
+        # Set the parent
+        build_file.parent = build_phase
+
+        # Add the file to the internal index
+        @objects_by_id[build_file.id] = build_file
+
+        # Add the file to the build phase
+        build_phase.attributes['files'] << build_file.id
+
+      end
+
+    end
+
     def to_ascii_plist
       plist = { :archiveVersion => archive_version,
                 :classes => {},
@@ -240,10 +411,48 @@ module Vendor::XCode
 
     private
 
+      def build_phase_for_file(file_type, target)
+        # Which build phase does this file belong?
+        klass = case file_type
+          when "sourcecode.c.objc"
+            Vendor::XCode::Proxy::PBXSourcesBuildPhase
+          when "wrapper.framework"
+            Vendor::XCode::Proxy::PBXFrameworksBuildPhase
+        end
+
+        if klass
+          # Find the build phase
+          build_phase = target.build_phases.find { |phase| phase.kind_of?(klass) }
+          unless build_phase
+            Vendor.ui.error "Could not find '#{klass.name}' build phase for target '#{target.name}'"
+            exit 1
+          end
+          build_phase
+        else
+          false
+        end
+      end
+
       def require_options(options, *keys)
         keys.each { |k| raise StandardError.new("Missing :#{k} option") unless options[k] }
       end
 
+      def targets_from_options(options)
+        if options[:targets]
+          [ *options[:targets] ].map do |t|
+            if t == :all
+              root_object.targets
+            else
+              target = find_target(t)
+              raise StandardError.new("Could not find target '#{t}' in project '#{name}'") unless target
+              target
+            end
+          end.flatten.uniq
+        else
+          root_object.targets
+        end
+      end
+
   end
 
 end