doubleshot 0.2.0-java → 0.3.0-java

data/lib/doubleshot/resolver.rb

@@ -19,4 +19,5 @@ class Doubleshot
   end
 end
 
+require "doubleshot/resolver/gem_resolver"
 require "doubleshot/resolver/jar_resolver"

data/lib/doubleshot/resolver/gem_resolver.rb

@@ -0,0 +1,45 @@
+class Doubleshot
+  class Resolver
+    class GemResolver < Resolver
+      DEFAULT_REPOSITORY = "http://rubygems.org"
+
+      def initialize(*repositories)
+        super
+        @graph = Graph.new(*repositories)
+      end
+
+      def resolve!(dependencies)
+        demands = dependencies.map do |dependency|
+          if dependency.requirements.empty?
+            dependency.name
+          else
+            [ dependency.name, *dependency.requirements.map { |requirement| requirement.to_s } ]
+          end
+        end
+
+        ui = Class.new do
+          def say(*args)
+            STDERR.puts *args
+          end
+        end.new
+        ui = nil
+        results = Solver.new(@graph, demands, ui).resolve
+
+        results.each_pair do |name, version|
+          dependencies.fetch(name).lock(version)
+        end
+
+        dependencies
+      end
+
+    end
+  end
+end
+
+require "doubleshot/resolver/gem_resolver/source"
+require "doubleshot/resolver/gem_resolver/artifact"
+require "doubleshot/resolver/gem_resolver/demand"
+require "doubleshot/resolver/gem_resolver/dependency"
+require "doubleshot/resolver/gem_resolver/errors"
+require "doubleshot/resolver/gem_resolver/graph"
+require "doubleshot/resolver/gem_resolver/solver"

data/lib/doubleshot/resolver/gem_resolver/artifact.rb

@@ -0,0 +1,146 @@
+class Doubleshot
+  class Resolver
+    class GemResolver
+      class Artifact
+        include Comparable
+
+        # A reference to the graph this artifact belongs to
+        #
+        # @return [Doubleshot::Resolver::GemResolver::Graph]
+        attr_reader :graph
+
+        # The name of the artifact
+        #
+        # @return [String]
+        attr_reader :name
+
+        # The version of this artifact
+        #
+        # @return [Gem::Version]
+        attr_reader :version
+
+        # @param [Doubleshot::Resolver::GemResolver::Graph] graph
+        # @param [#to_s] name
+        # @param [Gem::Version, #to_s] version
+        def initialize(graph, name, version)
+          @graph = graph
+          @name = name
+          @version = Gem::Version.new(version)
+          @dependencies = Hash.new
+        end
+
+        # Return the Doubleshot::Resolver::GemResolver::Dependency from the collection of
+        # dependencies with the given name and constraint.
+        #
+        # @param [#to_s] name
+        # @param [Gem::Requirement, #to_s] constraint
+        #
+        # @example adding dependencies
+        #   artifact.depends("nginx") => <#Dependency: @name="nginx", @constraint=">= 0.0.0">
+        #   artifact.depends("ntp", "= 1.0.0") => <#Dependency: @name="ntp", @constraint="= 1.0.0">
+        #
+        # @example chaining dependencies
+        #   artifact.depends("nginx").depends("ntp")
+        #
+        # @return [Doubleshot::Resolver::GemResolver::Artifact]
+        def depends(name, constraint = ">= 0")
+          if name.nil?
+            raise ArgumentError, "A name must be specified. You gave: #{args}."
+          end
+
+          dependency = Dependency.new(self, name, constraint)
+          add_dependency(dependency)
+
+          self
+        end
+
+        # Return the collection of dependencies on this instance of artifact
+        #
+        # @return [Array<Doubleshot::Resolver::GemResolver::Dependency>]
+        def dependencies
+          @dependencies.collect { |name, dependency| dependency }
+        end
+
+        # Retrieve the dependency from the artifact with the matching name and constraint
+        #
+        # @param [#to_s] name
+        # @param [#to_s] constraint
+        #
+        # @return [Doubleshot::Resolver::GemResolver::Artifact, nil]
+        def get_dependency(name, constraint)
+          @dependencies.fetch(Graph.dependency_key(name, constraint), nil)
+        end
+
+        # Remove this artifact from the graph it belongs to
+        #
+        # @return [Doubleshot::Resolver::GemResolver::Artifact, nil]
+        def delete
+          unless graph.nil?
+            result = graph.remove_artifact(self)
+            @graph = nil
+            result
+          end
+        end
+
+        def to_s
+          "#{name}-#{version}"
+        end
+
+        # @param [Object] other
+        #
+        # @return [Boolean]
+        def ==(other)
+          other.is_a?(self.class) &&
+            self.name == other.name &&
+            self.version == other.version
+        end
+        alias_method :eql?, :==
+
+        # @param [Gem::Version] other
+        #
+        # @return [Integer]
+        def <=>(other)
+          self.version <=> other.version
+        end
+
+        private
+
+        # Add a Doubleshot::Resolver::GemResolver::Dependency to the collection of dependencies
+        # and return the added Doubleshot::Resolver::GemResolver::Dependency. No change will be
+        # made if the dependency is already a member of the collection.
+        #
+        # @param [Doubleshot::Resolver::GemResolver::Dependency] dependency
+        #
+        # @return [Doubleshot::Resolver::GemResolver::Dependency]
+        def add_dependency(dependency)
+          unless has_dependency?(dependency.name, dependency.constraint)
+            @dependencies[Graph.key_for(dependency)] = dependency
+          end
+
+          get_dependency(dependency.name, dependency.constraint)
+        end
+
+        # Remove the matching dependency from the artifact
+        #
+        # @param [Doubleshot::Resolver::GemResolver::Dependency] dependency
+        #
+        # @return [Doubleshot::Resolver::GemResolver::Dependency, nil]
+        def remove_dependency(dependency)
+          if has_dependency?(dependency)
+            @dependencies.delete(Graph.key_for(dependency))
+          end
+        end
+
+        # Check if the artifact has a dependency with the matching name and constraint
+        #
+        # @param [#to_s] name
+        # @param [#to_s] constraint
+        #
+        # @return [Boolean]
+        def has_dependency?(name, constraint)
+          @dependencies.has_key?(Graph.dependency_key(name, constraint))
+        end
+      end
+    end
+  end
+end

data/lib/doubleshot/resolver/gem_resolver/demand.rb

@@ -0,0 +1,57 @@
+class Doubleshot
+  class Resolver
+    class GemResolver
+      class Demand
+        # A reference to the solver this demand belongs to
+        #
+        # @return [Doubleshot::Resolver::GemResolver::Solver]
+        attr_reader :solver
+
+        # The name of the artifact this demand is for
+        #
+        # @return [String]
+        attr_reader :name
+
+        # The acceptable constraint of the artifact this demand is for
+        #
+        # @return [Gem::Requirement]
+        attr_reader :constraint
+
+        # @param [Doubleshot::Resolver::GemResolver::Solver] solver
+        # @param [#to_s] name
+        # @param [Gem::Requirement, #to_s] constraint
+        def initialize(solver, name, constraint = ">= 0")
+          @solver = solver
+          @name = name
+          @constraint = if constraint.is_a?(Gem::Requirement)
+            constraint
+          else
+            Gem::Requirement.new(constraint.to_s)
+          end
+        end
+
+        # Remove this demand from the solver it belongs to
+        #
+        # @return [Doubleshot::Resolver::GemResolver::Demand, nil]
+        def delete
+          unless solver.nil?
+            result = solver.remove_demand(self)
+            @solver = nil
+            result
+          end
+        end
+
+        def to_s
+          "#{name} (#{constraint})"
+        end
+
+        def ==(other)
+          other.is_a?(self.class) &&
+            self.name == other.name &&
+            self.constraint == other.constraint
+        end
+        alias_method :eql?, :==
+      end
+    end
+  end
+end

data/lib/doubleshot/resolver/gem_resolver/dependency.rb

@@ -0,0 +1,57 @@
+class Doubleshot
+  class Resolver
+    class GemResolver
+      class Dependency
+        # A reference to the artifact this dependency belongs to
+        #
+        # @return [Doubleshot::Resolver::GemResolver::Artifact]
+        attr_reader :artifact
+
+        # The name of the artifact this dependency represents
+        #
+        # @return [String]
+        attr_reader :name
+
+        # The constraint requirement of this dependency
+        #
+        # @return [Gem::Requirement]
+        attr_reader :constraint
+
+        # @param [Doubleshot::Resolver::GemResolver::Artifact] artifact
+        # @param [#to_s] name
+        # @param [Gem::Requirement, #to_s] constraint
+        def initialize(artifact, name, constraint = ">= 0")
+          @artifact = artifact
+          @name = name
+          @constraint = case constraint
+          when Gem::Requirement
+            constraint
+          else
+            Gem::Requirement.new(constraint)
+          end
+        end
+
+        # Remove this dependency from the artifact it belongs to
+        #
+        # @return [Doubleshot::Resolver::GemResolver::Dependency, nil]
+        def delete
+          unless artifact.nil?
+            result = artifact.remove_dependency(self)
+            @artifact = nil
+            result
+          end
+        end
+
+        # @param [Object] other
+        #
+        # @return [Boolean]
+        def ==(other)
+          other.is_a?(self.class) &&
+            self.artifact == other.artifact &&
+            self.constraint == other.constraint
+        end
+        alias_method :eql?, :==
+      end
+    end
+  end
+end

data/lib/doubleshot/resolver/gem_resolver/errors.rb

@@ -0,0 +1,37 @@
+class Doubleshot
+  class Resolver
+    class GemResolver
+      module Errors
+        class Doubleshot::Resolver::GemResolverError < StandardError; end
+
+        class InvalidVersionFormat < Doubleshot::Resolver::GemResolverError
+          attr_reader :version
+
+          # @param [#to_s] version
+          def initialize(version)
+            @version = version
+          end
+
+          def message
+            "'#{version}' did not contain a valid version string: 'x.y.z' or 'x.y'."
+          end
+        end
+
+        class InvalidConstraintFormat < Doubleshot::Resolver::GemResolverError
+          attr_reader :constraint
+
+          # @param [#to_s] constraint
+          def initialize(constraint)
+            @constraint = constraint
+          end
+
+          def message
+            "'#{constraint}' did not contain a valid operator or a valid version string."
+          end
+        end
+
+        class NoSolutionError < Doubleshot::Resolver::GemResolverError; end
+      end
+    end
+  end
+end

data/lib/doubleshot/resolver/gem_resolver/gem_source.rb

@@ -0,0 +1,58 @@
+require "open-uri"
+require "zlib"
+
+class Doubleshot
+  class Resolver
+    class GemResolver
+      class GemSource < Source
+
+        map :http, :https
+
+        SUPPORTED_PLATFORMS = [ /\bjava\b/i, /^jruby$/i, /^ruby$/i ]
+
+        def versions(name)
+          __versions__[name]
+        end
+
+        def spec(name, version)
+          __specs__[name][version]
+        end
+
+        private
+        def __specs__
+          @specs ||= begin
+            Hash.new do |h,name|
+              h[name] = Hash.new do |h2,version|
+                begin
+                  puts "Loading Gem::Specification for #{name}:#{version}..."
+                  Marshal.load(Gem.inflate(open(
+                    "#{@uri.to_s.ensure_ends_with("/")}quick/Marshal.4.8/#{name}-#{version}.gemspec.rz"
+                    ).read))
+                rescue
+                  puts "Gem::Specification for #{name}:#{version} not found!"
+                  nil
+                end
+              end
+            end
+          end
+        end
+
+        def __versions__
+          @versions ||= Hash.new do |h,k|
+            versions = h[k] = []
+            dep = Gem::Dependency.new(k, Gem::Requirement::default)
+            puts "Fetching list of versions for #{k.inspect}"
+            Gem::SpecFetcher::fetcher.find_matching(dep, true, false, false).map do |entry|
+              if tuple = entry.first
+                if SUPPORTED_PLATFORMS.any? { |platform| tuple.last =~ platform }
+                  versions << tuple[1]
+                end # if SUPPORTED_PLATFORMS
+              end # if tuple = entry.first
+            end # Gem::SpecFetcher::fetcher.find_matching
+            versions
+          end # Hash.new
+        end # __versions__
+      end
+    end
+  end
+end

data/lib/doubleshot/resolver/gem_resolver/graph.rb

@@ -0,0 +1,200 @@
+class Doubleshot
+  class Resolver
+    class GemResolver
+      class Graph
+        # Create a key for a graph from an instance of an Artifact or Dependency
+        #
+        # @param [Doubleshot::Resolver::GemResolver::Artifact, Doubleshot::Resolver::GemResolver::Dependency] object
+        #
+        # @raise [ArgumentError] if an instance of an object of an unknown type is given
+        #
+        # @return [Symbol]
+        def self.key_for(object)
+          case object
+          when Doubleshot::Resolver::GemResolver::Artifact
+            artifact_key(object.name, object.version)
+          when Doubleshot::Resolver::GemResolver::Dependency
+            dependency_key(object.name, object.constraint)
+          else
+            raise ArgumentError, "Could not generate graph key for Class: #{object.class}"
+          end
+        end
+
+        # Create a key representing an artifact for an instance of Graph
+        #
+        # @param [#to_s] name
+        # @param [#to_s] version
+        #
+        # @return [Symbol]
+        def self.artifact_key(name, version)
+          "#{name}-#{version}".to_sym
+        end
+
+        # Create a key representing an dependency for an instance of Graph
+        #
+        # @param [#to_s] name
+        # @param [#to_s] constraint
+        #
+        # @return [Symbol]
+        def self.dependency_key(name, constraint)
+          "#{name}-#{constraint}".to_sym
+        end
+
+        def initialize(*repositories)
+          @sources   = repositories.map do |repository|
+            Source.new(repository)
+          end
+          @versions  = Hash.new
+          @artifacts = Hash.new
+        end
+
+        # @overload artifacts(name, version)
+        #   Return the Doubleshot::Resolver::GemResolver::Artifact from the collection of artifacts
+        #   with the given name and version.
+        #
+        #   @param [#to_s]
+        #   @param [Gem::Version, #to_s]
+        #
+        #   @return [Doubleshot::Resolver::GemResolver::Artifact]
+        # @overload artifacts
+        #   Return the collection of artifacts
+        #
+        #   @return [Array<Doubleshot::Resolver::GemResolver::Artifact>]
+        def artifacts(*args)
+          if args.empty?
+            return artifact_collection
+          end
+          unless args.length == 2
+            raise ArgumentError, "Unexpected number of arguments. You gave: #{args.length}. Expected: 0 or 2."
+          end
+
+          name, version = args
+
+          if name.nil? || version.nil?
+            raise ArgumentError, "A name and version must be specified. You gave: #{args}."
+          end
+
+          artifact = Artifact.new(self, name, version)
+          add_artifact(artifact)
+        end
+
+        # Return all the artifacts from the collection of artifacts
+        # with the given name.
+        #
+        # @param [String] name
+        #
+        # @return [Array<Doubleshot::Resolver::GemResolver::Artifact>]
+        def versions(name, constraint = ">= 0.0.0")
+          constraint = constraint.is_a?(Gem::Requirement) ? constraint : Gem::Requirement.new(constraint)
+
+          if @sources.empty?
+            # ORIGINAL CODE FROM Solve PROJECT. DO NOT TOUCH!
+            artifacts.select do |artifact|
+              artifact.name == name && constraint.satisfied_by?(artifact.version)
+            end
+          else
+            @sources.map do |source|
+              source.versions(name).select do |version|
+                constraint.satisfied_by?(version)
+              end.map do |version|
+                Artifact.new(self, name, version)
+              end
+            end.flatten
+          end
+        end
+
+        # Add a Doubleshot::Resolver::GemResolver::Artifact to the collection of artifacts and
+        # return the added Doubleshot::Resolver::GemResolver::Artifact. No change will be made
+        # if the artifact is already a member of the collection.
+        #
+        # @param [Doubleshot::Resolver::GemResolver::Artifact] artifact
+        #
+        # @return [Doubleshot::Resolver::GemResolver::Artifact]
+        def add_artifact(artifact)
+          unless has_artifact?(artifact.name, artifact.version)
+            @artifacts[self.class.key_for(artifact)] = artifact
+          end
+
+          get_artifact(artifact.name, artifact.version)
+        end
+
+        # Retrieve the artifact from the graph with the matching name and version
+        #
+        # @param [String] name
+        # @param [Gem::Version, #to_s] version
+        #
+        # @return [Doubleshot::Resolver::GemResolver::Artifact, nil]
+        def get_artifact(name, version)
+          if @sources.empty?
+            @artifacts.fetch(self.class.artifact_key(name, version.to_s), nil)
+          else
+            artifact = nil
+            @sources.any? do |source|
+              if spec = source.spec(name, version)
+                artifact = Artifact.new(self, name, version)
+                spec.runtime_dependencies.each do |dependency|
+                  dependency.requirements_list.each do |requirement|
+                    artifact.depends(dependency.name, requirement.to_s)
+                  end
+                end
+                true
+              end
+            end
+            artifact
+          end
+        end
+
+        # Remove the given instance of artifact from the graph
+        #
+        # @param [Doubleshot::Resolver::GemResolver::Artifact, nil] artifact
+        def remove_artifact(artifact)
+          if has_artifact?(artifact.name, artifact.version)
+            @artifacts.delete(self.class.key_for(artifact))
+          end
+        end
+
+        # Check if an artifact with a matching name and version is a member of this instance
+        # of graph
+        #
+        # @param [String] name
+        # @param [Gem::Version, #to_s] version
+        #
+        # @return [Boolean]
+        def has_artifact?(name, version)
+          !get_artifact(name, version).nil?
+        end
+
+        # @param [Object] other
+        #
+        # @return [Boolean]
+        def ==(other)
+          return false unless other.is_a?(self.class)
+
+          self_artifacts = self.artifacts
+          other_artifacts = other.artifacts
+
+          self_dependencies = self_artifacts.inject([]) do |list, artifact|
+            list << artifact.dependencies
+          end.flatten
+
+          other_dependencies = other_artifacts.inject([]) do |list, artifact|
+            list << artifact.dependencies
+          end.flatten
+
+          self_artifacts.size == other_artifacts.size &&
+          self_dependencies.size == other_dependencies.size &&
+          self_artifacts.all? { |artifact| other_artifacts.include?(artifact) } &&
+          self_dependencies.all? { |dependency| other_dependencies.include?(dependency) }
+        end
+        alias_method :eql?, :==
+
+        private
+
+        # @return [Array<Doubleshot::Resolver::GemResolver::Artifact>]
+        def artifact_collection
+          @artifacts.collect { |name, artifact| artifact }
+        end
+      end
+    end
+  end
+end