vendor 0.0.4 → 0.1

data/lib/vendor/templates/Vendorfile

@@ -1,3 +1,5 @@
-source :vendorforge
+# This is an example Vendorfile for you to start editing and add your
+# own dependencies. Check out http://github.com/keithpitt/vendor for
+# more information on how to use this file.
 
 lib "DKBenchmark", "0.2"

data/lib/vendor/templates/vendorspec

@@ -1,15 +1,20 @@
 # This is a generated version of the vendorspec. Please change the
-# values to suit your library. Refer to the documentation for a list of
-# all possible attributes.
+# values to suit your library.
 
-name          "<%= name %>"
-version       "0.1"
+Vendor::Spec.new do |s|
 
-authors       "<%= username %>"
-email         "<%= email %>"
-homepage      "HOMEPAGE GOES HERE"
-description   "DESCRIPTION GOES HERE"
+  s.name         "<%= name %>"
+  s.version      "0.1"
 
-github        "GITHUB LINK GOES HERE"
+  s.authors      "<%= username %>"
+  s.email        "<%= email %>"
+  s.description  "DESCRIPTION GOES HERE"
 
-files         `git ls-files`.split("\n")
+  # s.homepage     "HOMEPAGE URL GOES HERE"
+  # s.source       "SOURCE URL GOES HERE"
+
+  s.files        `git ls-files`.split("\n")
+
+  # s.dependency   "JSONKit", "0.5"
+
+end

data/lib/vendor/vendor_file.rb

@@ -2,10 +2,11 @@ module Vendor
 
   module VendorFile
 
-    autoload :Source,  "vendor/vendor_file/source"
-    autoload :Loader,  "vendor/vendor_file/loader"
-    autoload :DSL,     "vendor/vendor_file/dsl"
-    autoload :Library, "vendor/vendor_file/library"
+    autoload :Source,           "vendor/vendor_file/source"
+    autoload :Loader,           "vendor/vendor_file/loader"
+    autoload :DSL,              "vendor/vendor_file/dsl"
+    autoload :Library,          "vendor/vendor_file/library"
+    autoload :DependencyGraph,  "vendor/vendor_file/dependency_graph"
 
   end
 

data/lib/vendor/vendor_file/dependency_graph.rb

@@ -0,0 +1,135 @@
+module Vendor
+  module VendorFile
+
+    class DependencyGraph
+
+      attr_accessor :libraries
+      attr_reader :libraries_to_install
+
+      def initialize(libs = nil)
+        self.libraries = libs
+      end
+
+      def libraries=(value)
+        if value
+          # We want our own array, not a pointer to the old one, but we
+          # can keep the contents, thats fine.
+          @libraries = [ *value ]
+        else
+          @libraries = nil
+        end
+      end
+
+      def dependency_graph
+        map = {}
+        _touched = {}
+        graph = []
+        @libraries.each do |lib|
+          if (x = _map(lib, map, _touched))
+            graph << x
+          end
+        end
+
+        return graph, map
+      end
+
+      def version_conflicts?
+        graph, map = dependency_graph
+
+        # The version conflict detector is pretty stupid, pretty much if
+        # two libraries are trying to include a lib of different
+        # versions:
+        # a requires b v1.0
+        # c requires b v1.1
+        # Then things will blow up.
+
+        @libraries_to_install = []
+
+        map.keys.sort.each do |name|
+
+          libs = map[name]
+
+          # Only populate the "targets" element if there is a specific
+          # target to add to.
+          found_targets = libs.find_all { |l| l.targets if l.targets }.map &:targets
+          targets = found_targets.empty? ? nil : found_targets.flatten.compact.uniq
+
+          version_to_install = libs.first
+
+          # Check for conflicts and try to resolve
+          if libs.length > 1
+
+            # Sort the versions, starting with the latest version first
+            versions = libs.sort.reverse
+
+            # This code is a little yucky, but what it does, is it tries
+            # to find the best version match for every other version in
+            # the loop. So, lets say we have versions => 0.1 and ~> 0.1,
+            # and we have an array of [ "0.1", "0.1.1" ], try and find
+            # the higest versiont that each likes. Once we know that, we
+            # uniqify the results. If we have more than 1, that means we
+            # have a conflict.
+            vvs = versions.map(&:version)
+            matched_versions = libs.map do |l|
+              l.version_matches_any?(vvs)
+            end.inject([]) do |uniqs, obj|
+              if uniqs.all? { |e| e != obj }
+                uniqs << obj
+              end
+              uniqs
+            end
+
+            if matched_versions.length > 1
+              version_to_install = nil
+            else
+              # Find the version we've recomended and install that one.
+              y = matched_versions.first
+              version_to_install = versions.find do |x|
+                x.version == y.to_s
+              end
+            end
+
+          end
+
+          # Are there multiple versions to install?
+          unless version_to_install
+            Vendor.ui.error "Multiple versions detected for #{name} (#{versions.map(&:version).join(', ')})"
+
+            # A semi-meaningfull error
+            libs.each do |v|
+              if v.parent
+                Vendor.ui.error "  #{v.description} is required by #{v.parent.description}"
+              else
+                Vendor.ui.error "  #{v.description} is required in the Vendorfile"
+              end
+            end
+
+            exit
+          else
+            @libraries_to_install << [ version_to_install, targets ]
+          end
+        end
+
+        false
+      end
+
+      private
+
+        def _map(library, map, _touched)
+          unless _touched[library.description]
+            # Add the library to the map
+            map[library.name] ||= []
+            map[library.name] << library
+
+            # So we don't traverse this object again
+            _touched[library.description] = true
+
+            # Return the graph
+            [ library.description, library.dependencies.map { |l| _map(l, map, _touched) }.compact ]
+          end
+        end
+
+    end
+
+  end
+end

data/lib/vendor/vendor_file/dsl.rb

@@ -15,6 +15,8 @@ module Vendor
       end
 
       def source(source)
+        Vendor.ui.warn "Having multiple vendor sources is currently not supported. It will be in a future release."
+
         @sources << Vendor::VendorFile::Source.new(source)
       end
 

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

@@ -6,32 +6,51 @@ module Vendor
 
       class Base
 
+        attr_accessor :parent
+
         attr_accessor :name
         attr_accessor :targets
         attr_accessor :require
+        attr_accessor :version
 
         def initialize(attributes = {})
           @source_tree = :group
+          @targets = [ :all ]
           attributes.each { |k, v| self.send("#{k}=", v) }
         end
 
         def targets=(value)
-          @targets = [ *value ]
+          if value
+            @targets = [ *value ]
+          end
         end
 
         alias :target= :targets=
 
         def cache_path
-          @cache_path ||= File.join(Vendor.library_path, self.class.name.split('::').last.downcase, name)
+          File.join(Vendor.library_path, self.class.name.split('::').last.downcase, name)
         end
 
         def download
           # Do nothing by default, leave that up to the implementation
         end
 
-        def install(project)
-          Vendor.ui.debug "Installing #{name} into #{project} (source_tree = #{@source_tree})"
+        # This method sucks. What we should be doing is passing a library to the Xcode project class
+        # to install. We shouldn't be interacting with it like this. Really, VendorFile::Library should
+        # extend Xcode::Library or something. That was its a little more modular.
+        def install(project, options = {})
+          # If the cache doesn't exist, download it
+          download unless cache_exists?
 
+          Vendor.ui.info %{Installing #{display_name}}
+
+          # Combine the local targets, with those targets specified in the options. Also
+          # for sanity reasons, flatten and uniqify them.
+          if @targets || options[:targets]
+            install_targets = [ @targets, options[:targets] ].compact.flatten.uniq
+          end
+
+          # The destination in the XCode project
           destination = "Vendor/#{name}"
 
           # Remove the group, and recreate
@@ -39,53 +58,183 @@ module Vendor
 
           # Install the files back into the project
           files.each do |file|
-            Vendor.ui.debug "Copying file #{file} to #{destination}"
-
-            project.add_file :targets => targets, :path => destination,
+            project.add_file :targets => install_targets, :path => destination,
                              :file => file, :source_tree => @source_tree
           end
+
+          # Add frameworks
+          frameworks.each do |framework|
+            project.add_framework framework, :targets => install_targets
+          end
+
+          # Add compiler flags
+          build_settings.each do |build_setting|
+            project.add_build_setting build_setting[0], build_setting[1], :targets => install_targets, :from => self
+          end
         end
 
-        def files
-          unless File.exist?(cache_path)
-            Vendor.ui.error "Could not find libray `#{name}` at path `#{cache_path}`"
-            return []
+        def dependencies
+          # If the cache doesn't exist, download it
+          download unless cache_exists?
+
+          # Find the dependencies
+          dependencies = if manifest
+            manifest['dependencies']
+          elsif vendor_spec
+            vendor_spec.dependencies
           end
 
-          # Try and find a vendorspec in the cached folder
-          vendor_spec = Dir[File.join(cache_path, "*.vendorspec")].first
+          # Create remote objects to represent the dependencies
+          (dependencies || []).map do |d|
+            Vendor::VendorFile::Library::Remote.new(:name => d[0], :version => d[1], :parent => self, :targets => @targets)
+          end
+        end
+
+        def frameworks
+          # If the cache doesn't exist, download it
+          download unless cache_exists?
+
+          # Find the frameworks
+          frameworks = if manifest
+            manifest['frameworks']
+          elsif vendor_spec
+            vendor_spec.frameworks
+          end
+
+          frameworks || []
+        end
 
-          # Try and find a manifest (a built vendor file)
-          manifest = File.join(cache_path, "vendor.json")
+        def build_settings
+          # If the cache doesn't exist, download it
+          download unless cache_exists?
+
+          # Find the build settings
+          build_settings = if manifest
+            manifest['build_settings']
+          elsif vendor_spec
+            vendor_spec.build_settings
+          end
+
+          build_settings || []
+        end
+
+        def files
+          # If the cache doesn't exist, download it
+          download unless cache_exists?
 
           # Calculate the files we need to add. There are 3 different types
           # of installation:
           # 1) Installation from a manifest (a built lib)
           # 2) Loading the .vendorspec and seeing what files needed to be added
           # 3) Try to be smart and try and find files to install
-          install_files = if manifest && File.exist?(manifest)
+          install_files = if manifest
+                            manifest['files'].map do |file|
+                              File.join(cache_path, "data", file)
+                            end
+                          elsif vendor_spec
+                            vendor_spec.files.map do |file|
+                              File.join(cache_path, file)
+                            end
+                          else
+                            location = [ cache_path, self.require, "**/*.*" ].compact
+                            Dir[ File.join *location ]
+                          end
 
-            json = JSON.parse(File.read(manifest))
-            json['files'].map { |file| File.join(cache_path, "data", file) }
-
-          elsif vendor_spec && File.exist?(vendor_spec)
+          # Remove files that are within folders with a ".", such as ".bundle"
+          # and ".frameworks"
+          install_files.reject do |file|
+            file.gsub(cache_path, "") =~ /\/?[^\/]+\.[^\/]+\//
+          end
+        end
 
-            loader = Vendor::VendorSpec::Loader.new
-            loader.load vendor_spec
-            loader.dsl.files.map { |file| File.join(cache_path, file) }
+        def version
+          if @version
+            @version
+          elsif manifest
+            manifest['version']
+          elsif vendor_spec
+            vendor_spec.version
+          end
+        end
 
-          else
+        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)
 
-            location = [ cache_path, self.require, "**/*.*" ].compact
-            Dir[ File.join *location ]
+          # 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
 
-          # Remove files that are within folders with a ".", such as ".bundle"
-          # and ".frameworks"
-          install_files.reject { |file| file =~ /\/?[^\/]+\.[^\/]+\// }
+          versions.find { |has| wants == has }
+        end
+
+        def <=>(other)
+          v = other.respond_to?(:version) ? other.version : other
+          Vendor::Version.create(version) <=> Vendor::Version.create(v)
+        end
+
+        def ==(other)
+          other.name == name && other.version == version
+        end
+
+        def display_name
+          description
         end
 
+        def description
+          [ name, version ].compact.join(" ")
+        end
+
+        private
+
+          def cache_exists?
+            File.exist?(cache_path)
+          end
+
+          def vendor_spec
+            # Cache the vendor spec
+            return @vendor_spec if @vendor_spec
+
+            # Try and find a vendorspec in the cached folder
+            if cache_path
+              file = Dir[File.join(cache_path, "*.vendorspec")].first
+
+              if file && File.exist?(file)
+                @vendor_spec = Vendor::Spec.load(file)
+              else
+                false
+              end
+            else
+              false
+            end
+          end
+
+          def manifest
+            # Cache the manifest
+            return @manifest if @manifest
+
+            # Try and find a manifest (a built vendor file)
+            if cache_path
+              file = File.join(cache_path, "vendor.json")
+
+              if File.exist?(file)
+                @manifest = JSON.parse(File.read(file))
+              else
+                false
+              end
+            else
+              false
+            end
+          end
+
       end
 
     end