solve 0.2.1

data/lib/solve/constraint.rb

@@ -0,0 +1,73 @@
+module Solve
+  class Constraint
+    class << self
+      # @param [#to_s] string
+      #
+      # @return [Array, nil]
+      def parse(string)
+        if string =~ /^[0-9]/
+          op = "="
+          ver = string
+        else
+          _, op, ver = REGEXP.match(string).to_a
+        end
+
+        return nil unless op || ver
+
+        [ op, ver ]
+      end
+    end
+
+    OPERATORS = [
+      "=",
+      ">",
+      "<",
+      ">=",
+      "<=",
+      "~>"
+    ]
+    REGEXP = /^(#{OPERATORS.join('|')}) (.+)$/
+
+    attr_reader :operator
+    attr_reader :version
+
+    # @param [#to_s] constraint
+    def initialize(constraint = ">= 0.0.0")
+      @operator, ver_str = self.class.parse(constraint)
+      if @operator.nil? || ver_str.nil?
+        raise InvalidConstraintFormat.new(constraint)
+      end
+
+      @version = Version.new(ver_str)
+      @dep_constraint = DepSelector::VersionConstraint.new(constraint)
+    end
+
+    # Returns true or false if the given version would be satisfied by
+    # the version constraint.
+    #
+    # @param [Version, String] version
+    #
+    # @return [Boolean]
+    def satisfies?(version)
+      dep_constraint.include?(version)
+    end
+
+    # @param [Object] other
+    #
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(self.class) &&
+        self.operator == other.operator &&
+        self.version == other.version
+    end
+    alias_method :eql?, :==
+
+    def to_s
+      "#{operator} #{version}"
+    end
+
+    private
+
+      attr_reader :dep_constraint
+  end
+end

data/lib/solve/core_ext.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/core_ext/*.rb"].sort.each do |path|
+  require "solve/core_ext/#{File.basename(path, '.rb')}"
+end

data/lib/solve/core_ext/kernel.rb

@@ -0,0 +1,33 @@
+# From ActiveSupport: https://github.com/rails/rails/blob/c2c8ef57d6f00d1c22743dc43746f95704d67a95/activesupport/lib/active_support/core_ext/kernel/reporting.rb#L39
+
+require 'rbconfig'
+
+module Kernel
+  # Silences any stream for the duration of the block.
+  #
+  #   silence_stream(STDOUT) do
+  #     puts 'This will never be seen'
+  #   end
+  #
+  #   puts 'But this will'
+  def silence_stream(stream)
+    old_stream = stream.dup
+    stream.reopen(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ? 'NUL:' : '/dev/null')
+    stream.sync = true
+    yield
+  ensure
+    stream.reopen(old_stream)
+  end
+
+  # Silences both STDOUT and STDERR, even for subprocesses.
+  #
+  #   quietly { system 'bundle install' }
+  #
+  def quietly
+    silence_stream(STDOUT) do
+      silence_stream(STDERR) do
+        yield
+      end
+    end
+  end
+end

data/lib/solve/demand.rb

@@ -0,0 +1,38 @@
+module Solve
+  class Demand
+    attr_reader :graph
+    attr_reader :name
+    attr_reader :constraint
+
+    # @param [Solve::Graph] graph
+    # @param [#to_s] name
+    # @param [Solve::Constraint, #to_s] constraint
+    def initialize(graph, name, constraint = nil)
+      @graph = graph
+      @name = name
+
+      if constraint
+        @constraint = if constraint.is_a?(Solve::Constraint)
+          constraint
+        else
+          Constraint.new(constraint.to_s)
+        end
+      end
+    end
+
+    # @return [Solve::Demand, nil]
+    def delete
+      unless graph.nil?
+        result = graph.remove_demand(self)
+        @graph = nil
+        result
+      end
+    end
+
+    def to_s
+      s = "#{name}"
+      s << "(#{constraint})" if constraint
+      s
+    end
+  end
+end

data/lib/solve/dependency.rb

@@ -0,0 +1,40 @@
+module Solve
+  class Dependency
+    attr_reader :artifact
+    attr_reader :name
+    attr_reader :constraint
+
+    # @param [Solve::Artifact] artifact
+    # @param [#to_s] name
+    # @param [Solve::Constraint, #to_s] constraint
+    def initialize(artifact, name, constraint)
+      @artifact = artifact
+      @name = name
+      @constraint = case constraint
+      when Solve::Constraint
+        constraint
+      else
+        Constraint.new(constraint)
+      end
+    end
+
+    # @return [Solve::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

data/lib/solve/errors.rb

@@ -0,0 +1,31 @@
+module Solve
+  class SolveError < StandardError; end
+
+  class InvalidVersionFormat < SolveError
+    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 < SolveError
+    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 < SolveError; end
+end

data/lib/solve/gem_version.rb

@@ -0,0 +1,3 @@
+module Solve
+  VERSION = "0.2.1"
+end

data/lib/solve/graph.rb

@@ -0,0 +1,152 @@
+module Solve
+  class Graph
+    def initialize
+      @artifacts = Hash.new
+      @demands = Hash.new
+      @dep_graph = DepSelector::DependencyGraph.new
+    end
+
+    # @overload artifacts(name, version)
+    #   Return the Solve::Artifact from the collection of artifacts
+    #   with the given name and version.
+    #
+    #   @param [#to_s]
+    #   @param [Solve::Version, #to_s]
+    #
+    #   @return [Solve::Artifact]
+    # @overload artifacts
+    #   Return the collection of artifacts
+    #
+    #   @return [Array<Solve::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
+
+    # Add a Solve::Artifact to the collection of artifacts and
+    # return the added Solve::Artifact. No change will be made
+    # if the artifact is already a member of the collection.
+    #
+    # @param [Solve::Artifact] artifact
+    #
+    # @return [Solve::Artifact]
+    def add_artifact(artifact)
+      unless has_artifact?(artifact)
+        @dep_graph.package(artifact.name).add_version(DepSelector::Version.new(artifact.version.to_s))
+        @artifacts[artifact.to_s] = artifact
+      end
+
+      artifact
+    end
+
+    # @param [Solve::Artifact, nil] artifact
+    def remove_artifact(artifact)
+      if has_artifact?(artifact)
+        @dep_graph.packages.delete(artifact.to_s)
+        @artifacts.delete(artifact.to_s)
+      end
+    end
+
+    # @param [Solve::Artifact] artifact
+    #
+    # @return [Boolean]
+    def has_artifact?(artifact)
+      @artifacts.has_key?(artifact.to_s)
+    end
+
+    # @overload demands(name, constraint)
+    #   Return the Solve::Demand from the collection of demands
+    #   with the given name and constraint.
+    #
+    #   @param [#to_s]
+    #   @param [Solve::Constraint, #to_s]
+    #
+    #   @return [Solve::Demand]
+    # @overload demands(name)
+    #   Return the Solve::Demand from the collection of demands
+    #   with the given name.
+    #
+    #   @param [#to_s]
+    #
+    #   @return [Solve::Demand]
+    # @overload demands
+    #   Return the collection of demands
+    #
+    #   @return [Array<Solve::Demand>]
+    def demands(*args)
+      if args.empty?
+        return demand_collection
+      end
+      if args.length > 2
+        raise ArgumentError, "Unexpected number of arguments. You gave: #{args.length}. Expected: 2 or less."
+      end
+
+      name, constraint = args
+      constraint ||= ">= 0.0.0"
+
+      if name.nil?
+        raise ArgumentError, "A name must be specified. You gave: #{args}."
+      end
+
+      demand = Demand.new(self, name, constraint)
+      add_demand(demand)
+    end
+
+    # Add a Solve::Demand to the collection of demands and
+    # return the added Solve::Demand. No change will be made
+    # if the demand is already a member of the collection.
+    #
+    # @param [Solve::Demand] demand
+    #
+    # @return [Solve::Demand]
+    def add_demand(demand)
+      unless has_demand?(demand)
+        @demands[demand.to_s] = demand
+      end
+
+      demand
+    end
+    alias_method :demand, :add_demand
+
+    # @param [Solve::Demand, nil] demand
+    def remove_demand(demand)
+      if has_demand?(demand)
+        @demands.delete(demand.to_s)
+      end
+    end
+
+    # @param [Solve::Demand] demand
+    #
+    # @return [Boolean]
+    def has_demand?(demand)
+      @demands.has_key?(demand.to_s)
+    end
+
+    private
+
+      attr_reader :dep_graph
+
+      # @return [Array<Solve::Artifact>]
+      def artifact_collection
+        @artifacts.collect { |name, artifact| artifact }
+      end
+
+      # @return [Array<Solve::Demand>]
+      def demand_collection
+        @demands.collect { |name, demand| demand }
+      end
+  end
+end

data/lib/solve/version.rb

@@ -0,0 +1,47 @@
+module Solve
+  class Version
+    include Comparable
+
+    attr_reader :major
+    attr_reader :minor
+    attr_reader :patch
+
+    # @param [#to_s] ver_str
+    def initialize(ver_str = String.new)
+      @major, @minor, @patch = parse(ver_str)
+    end
+
+    def <=>(other)
+      [:major, :minor, :patch].each do |method|
+        ans = (self.send(method) <=> other.send(method))
+        return ans if ans != 0
+      end
+      0
+    end
+
+    def eql?(other)
+      other.is_a?(Version) && self == other
+    end
+
+    def inspect
+      to_s
+    end
+
+    def to_s
+      "#{major}.#{minor}.#{patch}"
+    end
+
+    private
+
+      def parse(ver_str = String.new)
+        @major, @minor, @patch = case ver_str.to_s
+        when /^(\d+)\.(\d+)\.(\d+)$/
+          [ $1.to_i, $2.to_i, $3.to_i ]
+        when /^(\d+)\.(\d+)$/
+          [ $1.to_i, $2.to_i, 0 ]
+        else
+          raise InvalidVersionFormat.new(ver_str)
+        end
+      end
+  end
+end

data/solve.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/solve/gem_version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.authors               = ["Jamie Winsor"]
+  s.email                 = ["jamie@vialstudios.com"]
+  s.description           = %q{A Ruby constraint solver}
+  s.summary               = s.description
+  s.homepage              = "https://github.com/reset/solve"
+  
+  s.files                 = `git ls-files`.split($\)
+  s.executables           = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.test_files            = s.files.grep(%r{^spec/})
+  s.name                  = "solve"
+  s.require_paths         = ["lib"]
+  s.version               = Solve::VERSION
+  s.required_ruby_version = ">= 1.9.1"
+
+  s.add_runtime_dependency 'dep_selector', '~> 0.0.8'
+
+  s.add_development_dependency 'thor'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'fuubar'
+  s.add_development_dependency 'spork'
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'redcarpet'
+  s.add_development_dependency 'guard'
+  s.add_development_dependency 'guard-rspec'
+  s.add_development_dependency 'guard-spork'
+  s.add_development_dependency 'guard-yard'
+  s.add_development_dependency 'coolline'
+end