versus 0.1.0

data/lib/versus/resolver.rb

@@ -0,0 +1,303 @@
+module Version
+
+  # Version resolution takes a requirements list and can reduce it
+  # to a best fit list.
+  #
+  class Resolver
+
+    #
+    #
+    #
+    def initialize(*available)
+      @libraries = Hash.new{ |h,k| h[k] = {} }
+
+      available.each do |name, version, requirements|
+        add(name, version, requirements || {})
+      end
+    end
+
+    #
+    # Map of dependencies by name and version to requirements.
+    #
+    attr :libraries
+
+    #
+    # Add available library.
+    #
+    def add(name, version, requirements={})
+      name     = name.to_s
+      number   = Number.parse(version)
+      requires = {}
+
+      requirements.each do |n,c|
+        requires[n.to_s] = Constraint.parse(c)
+      end
+
+      @libraries[name][number] = requires
+    end
+
+    #
+    # Look-up requirements for a given name and version.
+    #
+    def requirements(name, number)
+      number = Version::Number.parse(number) #unless Version::Number === number
+      @libraries[name][number]
+    end
+
+    #
+    # Returns possibilities sorted in descending order.
+    #
+    def possibilities(name, constraint)
+      name       = name.to_s
+      constraint = Constraint.parse(constraint)
+
+      list = []
+      @libraries[name].each do |version, _|
+        if constraint.match?(version)
+          list << [name, version]
+        end
+      end
+
+      list.sort!{ |a,b| b[1] <=> a[1] }
+    end
+
+    #
+    # TODO: support resolution of multiple [name, versions] at once.
+    #
+    def resolve(name, number)
+      name   = name.to_s
+      number = Number.parse(number)
+
+      sheet = {}
+
+      result = resolve_(name, number, sheet)
+
+      #list.each do |name, version|
+      #  name   = name.to_s
+      #  number = Number.parse(version)
+      #
+      #  resolve_(name, number, sheet)
+      #end
+      result ? sheet : nil
+    end
+
+  private
+
+    #
+    #
+    #
+    def resolve_(name, number, sheet={})
+      return false unless settle(name, number, sheet)
+
+      potents = requirements(name, number).map do |(n, c)|
+                  possibilities(n,c)
+                end
+
+      return sheet if potents.empty?
+
+      vectors = product(*potents)
+
+      success = vectors.find do |vector|
+                  resolve_vector(vector, sheet)
+                end
+
+      return success
+    end
+
+    #
+    #
+    #
+    def resolve_vector(vector, sheet)
+      vector.each do |(n,v)|
+        r = resolve_(n, v, sheet)
+        return false unless r
+      end
+      return sheet
+    end
+
+    #
+    #
+    #
+    def settle(name, number, sheet={})
+      if sheet[name]
+        return false if sheet[name] != number
+      else
+        sheet[name] = number
+      end
+      return true
+    end
+
+    #
+    #
+    #
+    def product(*list)
+      return [] if list.empty?
+      head, *rest = *list
+      head.product(*rest)
+    end
+
+=begin
+    #
+    #
+    #
+    def collect_possibilites
+      possibilites = Hash.new{ |h,k| h[k] = Hash.new{|h2,k2| h2[k2] = [] } }
+      constrained_versions = collect_constraints
+      libraries.each do |name, version, requirements|
+        requirements.each do |(n,c)|
+          possibilites[[name, version]][n] << constrained_versions[[n,c]]
+        end
+      end
+      possibilites
+    end
+
+    #
+    # Iterate over all requirements and collect all possible versions
+    # that fit their constraints.
+    #
+    def collect_constraints
+      constraints = {}
+      @libraries.each do |name, version, requirements|
+        requirements.each do |n,c|
+          next if constraints[[n,c]]
+          constraints[[n,c]] = matching_versions(n,c)
+        end
+      end
+      constraints
+    end
+
+    #
+    #
+    #
+    def matching_versions(name, constraint)
+      vers = @versions[name].select{ |v| constraint.fits?(v) }.sort
+      vers.map{ |v| [name, v] }
+    end
+=end
+
+
+
+=begin
+    # Resolve dependencies for given list of name-version.
+    #
+    # @param [Array] list
+    #
+    def resolve(list)
+      requirements = collect_requirements(list)
+
+      # time to do some backtracking
+      first, *rest = *requirements.values
+      first.product(*rest).find |possibility|
+        valid?(possibility)
+      end
+    end
+
+    #
+    # Collect requirements for given set of desired entries.
+    #
+    # TODO: Reduce requirements for same names
+    #
+    def collect_requirements(list)
+      requirements = {}
+      list.each do |(name, version)|
+        if @requirements.key?([name,version])
+          @requirements[[name,version]].each do |(n,c)|
+            next if requirements[[n,c]]
+            requirements[[n,c]] = matching_versions(n,c)
+          end
+        else
+          raise "no resolution - no available entry for #{name}-#{verison}"
+        end
+      end
+      requirements
+    end
+
+    #
+    #
+    #
+    def resolve_
+      reqs = {}
+      constraints.each do |name, *cons|
+        reqs[name] = reduce(*cons)
+      end
+      reqs
+    end
+
+    #
+    #
+    #
+    def constraints(list)
+      cons = {}
+      list.each do |(name, constraint)|
+        cons[name.to_s] ||= []
+        cons[name.to_s] << Constraint.parse(constraint)
+      end
+      cons
+    end
+=end
+
+    #
+    #
+    #
+    def reduce(*constraints)
+      exact, least, most = nil , nil, nil
+
+      constraints.each do |c|
+        case c.op
+        when '==', '='
+          if exact
+            if exact != c.number
+              exact, least, most = nil, nil, nil
+              break
+            end
+          else
+            exact = c
+          end
+        when '<'
+          if least
+            if c.number <= least.number
+              least = c
+            end
+          else
+            least = c
+          end
+        when '>'
+          if most
+            if c.number >= most.number
+              most = c
+            end
+          else
+            most = c
+          end
+        when '<='
+          if least
+            if c.number < least.number
+              least = c
+            end
+          else
+            least = c
+          end
+        when '>='
+          if most
+            if c.number > most.number
+              most = c
+            end
+          else
+            most = c
+          end
+        when '=~'
+          # TODO
+        end
+      end
+
+      # there be only one!
+      return nil if exact && least
+      return nil if exact && most
+      return nil if least && most
+
+      exact || least || most
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: versus
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- trans
+- postmodern
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: qed
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ae
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The Versus gem provides a solid Version class along with supporting functionality,
+  such as version constratints and version dependency resolution.
+email:
+- transfire@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- HISTORY.md
+- README.md
+files:
+- .index
+- .yardopts
+- demo/number/04_crush.md
+- demo/number/02_initialize.md
+- demo/number/09_stable_release.md
+- demo/number/03_parse.md
+- demo/number/20_to_str.md
+- demo/number/10_prerelease.md
+- demo/number/05_build.md
+- demo/number/19_match.md
+- demo/number/06_cmp.md
+- demo/number/08_bump.md
+- demo/number/07_segments.md
+- demo/number/11_release_candidate.md
+- demo/applique/main.rb
+- demo/applique/ae.rb
+- demo/resolver/06_resolve.md
+- demo/resolver/04_requirements.md
+- demo/resolver/02_add.md
+- demo/resolver/03_libraries.md
+- demo/resolver/05_possibilities.md
+- demo/resolver/01_initialize.md
+- demo/constraint/04_to_proc.md
+- demo/constraint/02_initialize.md
+- demo/constraint/09_to_gem_version.md
+- lib/versus.rb
+- lib/versus/file.rb
+- lib/versus/exceptions.rb
+- lib/versus/constraint.rb
+- lib/versus/core_ext/array.rb
+- lib/versus/core_ext/kernel.rb
+- lib/versus/core_ext/string.rb
+- lib/versus/file/jeweler_format.rb
+- lib/versus/file/plain_format.rb
+- lib/versus/resolver.rb
+- lib/versus/core_ext.rb
+- lib/versus/number.rb
+- LICENSE.txt
+- Index.yml
+- HISTORY.md
+- README.md
+homepage: http://dotruby.github.com
+licenses:
+- BSD-2-Clause
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Best-of-breed Version Class Library
+test_files: []