versus 0.1.0

data/demo/number/08_bump.md

@@ -0,0 +1,46 @@
+## Version::Number#bump
+
+A version number can be *bumped*, which means various segments
+can be incremented. Bumping is handled by the #bump method which
+is passed a symbol describing the type of bump to effect.
+
+### Bump major number
+
+    v = Version::Number[1,0,0]
+    v.bump(:major).to_s == '2.0.0'
+
+### Bump minor number
+
+    v = Version::Number[1,0,0]
+    v.bump(:minor).to_s == '1.1.0'
+
+### Bump patch number
+
+    v = Version::Number[1,0,0]
+    v.bump(:patch).to_s == '1.0.1'
+
+### Bump build number
+
+    v = Version::Number[1,0,0,0]
+    v.bump(:build).to_s == '1.0.0.1'
+
+### Bump build number with state
+
+    v = Version::Number[1,0,0,'pre',1]
+    v.bump(:build).to_s == '1.0.0.pre.2'
+
+### Bump state segment
+
+    v = Version::Number[1,0,0,'pre',2]
+    v.bump(:state).to_s == '1.0.0.rc.1'
+
+### Bump last segment
+
+    v = Version::Number[1,0,0,'pre',3]
+    v.bump(:last).to_s == '1.0.0.pre.4'
+
+### Reset State
+
+    v = Version::Number[1,0,0,'pre',2]
+    v.restate(:beta).to_s == '1.0.0.beta.1' 
+

data/demo/number/09_stable_release.md

@@ -0,0 +1,23 @@
+## Version::Number#stable?
+
+The `stable?` method returns `true` if the build is `nil`,
+otherwise `false`.
+
+    v = Version::Number[1,2,3]
+
+    v.assert.stable?
+
+    v = Version::Number[1,2,3,'pre',4]
+
+    v.refute.stable?
+
+
+## Version::Number#stable_release?
+
+    v = Version::Number[1,2,3]
+
+    v.assert.stable_release?
+
+    v = Version::Number[1,2,3,'pre',4]
+
+    v.refute.stable_release?

data/demo/number/10_prerelease.md

@@ -0,0 +1,19 @@
+## Version::Number#prerelease?
+
+The `prerelease?` method returns `true` if the build is `pre`,
+otherwise `false`.
+
+    v = Version::Number[1,2,3,'pre',4]
+
+    v.assert.prerelease?
+
+
+    v = Version::Number[1,2,3]
+
+    v.refute.prerelease?
+
+
+    v = Version::Number[1,2,3,'alpha']
+
+    v.refute.prerelease?
+

data/demo/number/11_release_candidate.md

@@ -0,0 +1,15 @@
+## Version::Number#release_candidate?
+
+The `release_candidate?` method returns `true` if the build
+is `rc`, otherwise `false`.
+
+    check do |v|
+      v = Version::Number.parse(v)
+      v.release_candidate?
+    end
+
+    ok [1,2,3,'rc',1]
+    no [1,2,3]
+    no [1,2,3,'alpha']
+
+

data/demo/number/19_match.md

@@ -0,0 +1,10 @@
+## Version::Number#match?
+
+The `match?` method
+
+    v = Version::Number[1,2,3]
+
+    v.assert.match?('> 1.2')
+    v.assert.match?('< 2.0')
+    v.assert.match?('> 1.2', '< 2.0')
+

data/demo/number/20_to_str.md

@@ -0,0 +1,13 @@
+## Version::Number#to_str
+
+The Version::Number class can be thought of as a String.
+
+    check do |v, s|
+      v = Version::Number.parse(v)
+      v.to_str.assert == s
+    end
+
+    ok [1,2,3],         '1.2.3'
+    ok [1,2,3,'rc',1],  '1.2.3.rc.1'
+    ok [1,2,3,'alpha'], '1.2.3.alpha'
+

data/demo/resolver/01_initialize.md

@@ -0,0 +1,23 @@
+# Version::Resolver#initialize
+
+The Resolver class provides a means for resolving versioned 
+
+  resolver = Version::Resolver.new
+
+A new Resolver can take a list of dependent entries. These are supplied as
+a list of three-element arrays containing name, version number and requiremnets.
+Where requirements are themselves a list of names and version constraints.
+
+  resolver = Version::Resolver.new(
+    ['foo', '1.0.0', {'bar' => '> 1.0'}],
+    ['bar', '2.0.0', {}]
+  )
+
+If the requirements list is left out of an entry, it should still initialize
+without issue.
+
+  resolver = Version::Resolver.new(
+    ['foo', '1.0.0', {'bar' => '> 1.0'}],
+    ['bar', '2.0.0']
+  )
+

data/demo/resolver/02_add.md

@@ -0,0 +1,11 @@
+# Version::Resolver.add
+
+Rather then passing dependencies to the constructor, a Resolver can be
+initialized without arguments and then passed dependencies one at a time
+using the `#add` method.
+
+    resolver = Version::Resolver.new
+
+    resolver.add('foo', '1.0.0', 'bar'=>'> 1.0')
+    resolver.add('bar', '2.0.0')
+

data/demo/resolver/03_libraries.md

@@ -0,0 +1,24 @@
+# Version::Resolver#libraries
+
+Adding entries to the Resolver build up a map of "libraries".
+
+    resolver = Version::Resolver.new
+
+    resolver.add('foo', '1.0.0', 'bar'=>'> 1.0')
+    resolver.add('bar', '2.0.0')
+
+    resolver.libraries.assert.is_a?(Hash)
+
+The hash is made up of the libraries added to the reolver, just organized
+into two-tier hash of `name => version-number => requirements`.
+
+    resolver.libraries['foo'].assert.is_a?(Hash)
+
+But the version has version-number is converted into a Version::Number 
+instance, and the requirement's version constraint is converted into
+a Version::Constraint instance.
+
+    version = Version::Number.parse('1.0.0')
+
+    resolver.libraries['foo'][version].assert.is_a?(Hash)
+

data/demo/resolver/04_requirements.md

@@ -0,0 +1,13 @@
+# Version::Resolver#requirements
+
+Requiremnets can be looked-up using the `#requirements` method.
+
+    resolver = Version::Resolver.new
+
+    resolver.add('foo', '1.0.0', 'bar'=>'> 1.0')
+    resolver.add('bar', '2.0.0')
+
+    requires = resolver.requirements('foo', '1.0.0')
+
+    requires.keys.assert == ['bar']
+

data/demo/resolver/05_possibilities.md

@@ -0,0 +1,13 @@
+# Version::Resolver#possibilities
+
+Requiremnets can be looked-up using the `#requirements` method.
+
+    resolver = Version::Resolver.new
+
+    resolver.add('foo', '1.0.0', 'bar'=>'> 1.0')
+    resolver.add('bar', '2.0.0')
+
+    potents = resolver.possibilities('foo', '= 1.0.0')
+
+    potents.first.first.assert == 'foo'
+

data/demo/resolver/06_resolve.md

@@ -0,0 +1,42 @@
+# Version::Resolver#resolve
+
+Given a Resolver and a set of entries,
+
+    resolver = Version::Resolver.new
+
+    resolver.add('foo', '1.0.0', 'bar'=>'> 1.0')
+    resolver.add('bar', '1.0.0')
+    resolver.add('bar', '2.0.0')
+
+We can resolve the requirements
+
+    result = resolver.resolve('foo', '1.0.0')
+
+    result.assert == {'foo'=>Version['1.0.0'], 'bar'=>Version['2.0.0']}
+
+If there are not sufficient requirements then no resolution will be returned.
+
+    resolver = Version::Resolver.new
+
+    resolver.add('foo', '1.0.0', 'bar'=>'> 1.0')
+    resolver.add('bar', '1.0.0')
+
+    result = resolver.resolve('foo', '1.0.0')
+
+    result.assert == nil
+
+Let try a more complex example to be sure of our algorithm.
+
+    resolver.add('foo', '1.0.0', 'bar'=>'> 1.0', 'baz'=>'> 2.0')
+    resolver.add('bar', '1.0.0', 'baz'=>'= 3.1')
+    resolver.add('bar', '2.0.0', 'baz'=>'= 3.1')
+    resolver.add('baz', '2.9.0')
+    resolver.add('baz', '3.1.0')
+    resolver.add('baz', '3.2.0')
+
+    result = resolver.resolve('foo', '1.0.0')
+
+    result.assert == { 'foo'=>Version['1.0.0'],
+                       'bar'=>Version['2.0.0'],
+                       'baz'=>Version['3.1.0'] }
+

data/lib/versus.rb

@@ -0,0 +1,5 @@
+require 'versus/exceptions'
+require 'versus/number'
+require 'versus/constraint'
+require 'versus/resolver'
+require 'versus/file'

data/lib/versus/constraint.rb

@@ -0,0 +1,130 @@
+module Version
+
+  # The Constraint class models a single version equality or inequality.
+  # It consists of the operator and the version number.
+  #--
+  # TODO: Please improve me!
+  #
+  # TODO: This should ultimately replace the class methods of Version::Number.
+  #
+  # TODO: Do we need to support version "from-to" spans ?
+  #++
+  class Constraint
+
+    #
+    def self.parse(constraint)
+      new(constraint)
+    end
+
+    #
+    def self.[](operator, number)
+      new([operator, number])
+    end
+
+    #
+    def initialize(constraint)
+      @operator, @number = parse(constraint || '0+')
+
+      case constraint
+      when Array
+        @stamp = "%s %s" % [@operator, @number]
+      when String
+        @stamp = constraint || '0+'
+      end
+    end
+
+    # Constraint operator.
+    attr :operator
+
+    # Verison number.
+    attr :number
+
+    #
+    def to_s
+      @stamp
+    end
+
+    # Converts the version into a constraint string recognizable
+    # by RubyGems.
+    #--
+    # TODO: Better name Constraint#to_s2.
+    #++
+    def to_gem_version
+      op = (operator == '=~' ? '~>' : operator)
+      "%s %s" % [op, number]
+    end
+
+    #
+    # Convert constraint to Proc object which can be
+    # used to test a version number.
+    #
+    def to_proc
+      lambda do |v|
+        n = Version::Number.parse(v)
+        n.send(operator, number)
+      end
+    end
+
+    #
+    def call(v)
+      n = Version::Number.parse(v)
+      n.send(operator, number)
+    end
+
+    # better name?
+    alias :match? :call
+
+  private
+
+    #
+    def parse(constraint)
+      case constraint
+      when Constraint
+        op, val = constraint.operator, constraint.number
+      when Array
+        op, num = constraint
+      when /^(.*?)\~$/
+        op, val = "=~", $1.strip
+      when /^(.*?)\+$/
+        op, val = ">=", $1.strip
+      when /^(.*?)\-$/
+        op, val = "<", $1
+      when /^(=~|~>|<=|>=|==|=|<|>)?\s*(\d+(:?[-.]\w+)*)$/
+        if op = $1
+          op = '=~' if op == '~>'
+          op = '==' if op == '='
+          val = $2.split(/\W+/)
+        else
+          op = '=='
+          val = constraint.split(/\W+/)
+        end
+      else
+        raise ArgumentError #constraint.split(/\s+/)
+      end
+      return op, Version::Number.new(*val)
+    end
+
+    # Parse package entry into name and version constraint.
+    #def parse(package)
+    #  parts = package.strip.split(/\s+/)
+    #  name = parts.shift
+    #  vers = parts.empty? ? nil : parts.join(' ')
+    # [name, vers]
+    #end
+
+  public
+
+    # Parses a string constraint returning the operation as a lambda.
+    def self.constraint_lambda(constraint)
+      new(constraint).to_proc
+    end
+
+    # Parses a string constraint returning the operator and value.
+    def self.parse_constraint(constraint)
+      c = new(constraint)
+      return c.operator, c.number
+    end
+
+  end
+
+end

data/lib/versus/core_ext.rb

@@ -0,0 +1,4 @@
+require 'versus/core_ext/array'
+require 'versus/core_ext/kernel'
+require 'versus/core_ext/string'
+

data/lib/versus/core_ext/array.rb

@@ -0,0 +1,11 @@
+require 'versus'
+
+class Array
+  #
+  # Converts the Array into a version number.
+  #
+  def to_version
+    Version::Number.new(*self)
+  end
+end
+

data/lib/versus/core_ext/kernel.rb

@@ -0,0 +1,19 @@
+require 'versus'
+
+module Kernel
+  private
+
+  #
+  # If an arbitrary object need to be converted to a `Version::Number`, this is
+  # a good way to do it.
+  #
+  # The capitalize method follows the Ruby conventions of `Array()` and `String()`, 
+  # etc. Though in this case `Version()` actually creates a `Version::Number` object,
+  # that is far an away the typical use case for the Version module.
+  #
+  def Version(version)
+    Version::Number.parse(version)
+  end
+
+end
+