grimoire 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ef5df1a91ba2a0ba8d102c0566e2eccca125678c
+  data.tar.gz: 7f2faf3d48426e22fee9ddf77d2c7845d1897071
+SHA512:
+  metadata.gz: 67788092dff047186519fff5efe33869c3395bda3769f49de24dca62d8a5e2a466d11278fbd770ed0cb14b212f782321a5c90c37ff8c9e6f555bfb68201a50cf
+  data.tar.gz: 548afdfb3c061bb89591113404c438e97d9ecf4ed7cb74b4cf5b843c4c2a820e998218bb3e3f2b72fbc5a262cf99c0ed61168f9f354cb7abd6c3ab76fb3f6125

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# v0.1.0
+* Initial commit

data/CONTRIBUTING.md

@@ -0,0 +1,25 @@
+# Contributing
+
+## Branches
+
+### `master` branch
+
+The master branch is the current stable released version.
+
+### `develop` branch
+
+The develop branch is the current edge of development.
+
+## Pull requests
+
+* https://github.com/spox/grimoire
+
+Please base all pull requests of the `develop` branch. Merges to
+`master` only occur through the `develop` branch. Pull requests
+based on `master` will likely be cherry picked.
+
+## Issues
+
+Need to report an issue? Use the github issues:
+
+* https://github.com/spox/grimoire

data/LICENSE

@@ -0,0 +1,13 @@
+   Copyright 2015 Chris Roberts
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,5 @@
+# Grimoire
+
+## Info
+
+* Repository: https://github.com/spox/grimoire

data/grimoire.gemspec

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
+require 'grimoire/version'
+Gem::Specification.new do |s|
+  s.name = 'grimoire'
+  s.version = Grimoire::VERSION.version
+  s.summary = 'Constraint solver'
+  s.author = 'Chris Roberts'
+  s.email = 'code@chrisroberts.org'
+  s.homepage = 'https://github.com/spox/grimoire'
+  s.description = 'Specialized constraint solver allowing weighted results'
+  s.require_path = 'lib'
+  s.license = 'Apache 2.0'
+  s.add_runtime_dependency 'bogo', '~> 0.1.10'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'pry'
+  s.files = Dir['{lib}/**/**/*'] + %w(grimoire.gemspec README.md CHANGELOG.md CONTRIBUTING.md LICENSE)
+end

data/lib/grimoire.rb

@@ -0,0 +1,24 @@
+require 'bogo'
+
+module Grimoire
+  # @todo Provide abstract interfaces for these and run validation on
+  #       defined classes to ensure expected methods
+
+  # Class used to define version information
+  VERSION_CLASS = Gem::Version
+  # Class used to define dependency information
+  DEPENDENCY_CLASS = Gem::Dependency
+  # Class used to define requirement
+  REQUIREMENT_CLASS = Gem::Requirement
+
+  autoload :Error, 'grimoire/error'
+  autoload :Path, 'grimoire/path'
+  autoload :RequirementList, 'grimoire/requirement_list'
+  autoload :Solver, 'grimoire/solver'
+  autoload :System, 'grimoire/system'
+  autoload :Unit, 'grimoire/unit'
+  autoload :Utility, 'grimoire/utility'
+
+end
+
+require 'grimoire/version'

data/lib/grimoire/error.rb

@@ -0,0 +1,19 @@
+require 'grimoire'
+
+module Grimoire
+
+  # General error
+  class Error < StandardError
+    # Requested unit is unavailable
+    class UnitUnavailable < Error
+      attr_accessor :unit_name
+    end
+    # Resolution path is not valid within constraints
+    class ResolutionPathInvalid < Error; end
+    # Too many loops run during path generation
+    class MaximumGenerationLoopsExceeded < Error; end
+    # No valid solution available
+    class NoSolution < Error; end
+  end
+
+end

data/lib/grimoire/path.rb

@@ -0,0 +1,14 @@
+require 'grimoire'
+
+module Grimoire
+  # Constraint resolution path
+  class Path < Utility
+
+    attribute :units, Unit, :multiple => true, :default => []
+
+    def dependencies
+      units.map(&:dependencies).flatten.uniq!
+    end
+
+  end
+end

data/lib/grimoire/requirement_list.rb

@@ -0,0 +1,11 @@
+require 'grimoire'
+
+module Grimoire
+
+  # Requirment list for solver
+  class RequirementList < Utility
+    attribute :name, String, :required => true, :coerce => lambda{|val| val.to_s}
+    attribute :requirements, DEPENDENCY_CLASS, :multiple => true, :default => [], :coerce => lambda{|val| DEPENDENCY_CLASS.new(val.first, *val.last)}
+  end
+
+end

data/lib/grimoire/solver.rb

@@ -0,0 +1,186 @@
+require 'grimoire'
+
+module Grimoire
+  # Requirement solver
+  class Solver < Utility
+
+    # Ceiling for number of loops allowed during path generation
+    MAX_GENERATION_LOOPS = 100000
+
+    include Bogo::Memoization
+
+    attribute :requirements, RequirementList, :required => true
+    attribute :system, System, :required => true
+
+    # @return [System] subset of full system based on requirements
+    attr_reader :world
+
+    def initialize(*_)
+      super
+      @world = System.new
+      build_world(requirements.requirements, world, system)
+      world.scrub!
+    end
+
+    # Build the world required for the solver (the subset of the
+    # entire system required by the requirements)
+    #
+    # @param deps [DEPENDENCY_CLASS] dependencies required to resolve
+    # @param my_world [System] system to populate with units
+    # @param root [System] superset system to extract units
+    def build_world(deps=nil, my_world=nil, root = nil)
+      deps = requirement.requirements unless deps
+      my_world = world unless my_world
+      root = system unless root
+      deps.each do |dep|
+        units = root.subset(dep.name, dep.requirement)
+        units.each do |unit|
+          build_world(unit.dependencies, my_world, root)
+        end
+        my_world.add_unit(units)
+      end
+    end
+
+    # @return [Smash<{Unit#name:Bogo::PriorityQueue}>]
+    def queues
+      memoize(:queues) do
+        Smash[
+          world.units.map do |name, items|
+            queue = Bogo::PriorityQueue.new
+            populate_queue(queue, items)
+            [name, queue]
+          end
+        ]
+      end
+    end
+
+    # Populate queue with units
+    #
+    # @param p_queue [Bogo::PriorityQueue]
+    # @param units [Array<Unit>]
+    # @return [Bogo::PriorityQueue]
+    def populate_queue(p_queue, units)
+      units.each_with_index do |unit, index|
+        p_queue.push(unit, score_unit(unit, index))
+      end
+      p_queue
+    end
+
+    # Provide score for given unit
+    #
+    # @param unit [Unit]
+    # @param score [Integer] current score
+    # @return [Integer] score
+    def score_unit(unit, score)
+      score
+    end
+
+    # Repopulate the given queue
+    #
+    # @param name [String]
+    # @return [self]
+    def reset_queue(name)
+      queue = populate_queue(
+        Bogo::PriorityQueue.new,
+        world.units[name]
+      )
+      queues[name] = queue
+      self
+    end
+
+    # Provide Unit acceptable for given dependency
+    #
+    # @param dep [DEPENDENCY_CLASS]
+    # @return [Unit]
+    # @raises [Error::UnitUnavailable]
+    def unit_for(dep)
+      unit = nil
+      until(unit || queues[dep.name].empty?)
+        unit = queues[dep.name].pop
+        unit = nil unless dep.requirement.satisfied_by?(unit.version)
+      end
+      unless(unit)
+        error = Error::UnitUnavailable.new("Failed to locate valid unit for: #{dep.inspect}")
+        error.unit_name = dep.name
+        raise error
+      end
+      unit
+    end
+
+    # Resolve path for a given dependency
+    #
+    # @param dep [DEPENDENCY_CLASS]
+    # @param given [DEPENDENCY_CLASS]
+    # @return [Array<Unit>]
+    def resolve(dep, given=nil)
+      unit = given || unit_for(dep)
+      if(unit.dependencies.empty?)
+        [unit]
+      else
+        deps = [unit]
+        begin
+          unit.dependencies.map do |u_dep|
+            existing = deps.detect{|d| d.name == u_dep.name}
+            if(existing)
+              if(u_dep.requirement.satisfied_by?(existing.version))
+                next
+              else
+                deps.delete(existing)
+                reset_queue(u_dep.name) unless given
+              end
+            else
+              reset_queue(u_dep.name) unless given
+            end
+            deps += resolve(u_dep)
+            deps.compact!
+            u_dep
+          end.compact.map do |u_dep|  # validator
+            existing = deps.detect{|d| d.name == u_dep.name}
+            if(existing)
+              unless(u_dep.requirement.satisfied_by?(existing.version))
+                deps.delete(existing)
+                reset_queue(u_dep.name)
+                raise Error::ResolutionPathInvalid.new("Unit <#{existing.inspect}> does not satisfy <#{u_dep.inspect}>")
+              end
+            end
+          end
+        rescue Error::ResolutionPathInvalid
+          retry
+        end
+        deps
+      end
+    end
+
+    # Generate valid constraint paths
+    #
+    # @return [Bogo::PriorityQueue<Path>]
+    def generate!
+      custom_unit = Unit.new(
+        :name => '~_SOLVER_UNIT_~',
+        :version => '1.0.0',
+        :dependencies => requirements.requirements
+      )
+      count = 0
+      results = Bogo::PriorityQueue.new
+      begin
+        until(count > MAX_GENERATION_LOOPS)
+          result = resolve(nil, custom_unit)
+          results.push(Path.new(:units => result.slice(1, result.size)), count)
+          count += 1
+        end
+      rescue Error::UnitUnavailable
+        count = nil
+      end
+      unless(count.nil?)
+        raise Error::MaximumGenerationLoopsExceeded.new("Exceeded maximum allowed loops for path generation: #{MAX_GENERATION_LOOPS}")
+      else
+        if(results.empty?)
+          raise Error::NoSolution.new("Failed to generate valid path for requirements: `#{custom_unit.dependencies.inspect}`")
+        else
+          results
+        end
+      end
+    end
+
+  end
+end

data/lib/grimoire/system.rb

@@ -0,0 +1,67 @@
+require 'grimoire'
+
+module Grimoire
+  # Contains all available Units
+  class System
+
+    # @return [Smash]
+    attr_reader :units
+
+    # Create new system
+    #
+    # @return [self]
+    def initialize(*_)
+      @units = Smash.new
+    end
+
+    # Register new unit
+    #
+    # @param unit [Unit]
+    # @return [self]
+    def add_unit(*unit)
+      [unit].flatten.compact.each do |u|
+        unless(units[u.name])
+          units[u.name] = []
+        end
+        units[u.name].push(u) unless units[u.name].include?(u)
+      end
+      self
+    end
+
+    # Remove registered unit
+    #
+    # @param unit [Unit]
+    # @param deps
+    # @return [self]
+    def remove_unit(unit)
+      if(units[unit.name])
+        units[unit.name].delete(unit)
+      end
+      self
+    end
+
+    # Provide all available units that satisfy the constraint
+    #
+    # @param unit_name [String]
+    # @param constraint [REQUIREMENT_CLASS]
+    # @return [Array<Unit>]
+    def subset(unit_name, constraint)
+      units[unit_name].find_all do |unit|
+        constraint.satisfied_by?(unit.version)
+      end
+    end
+
+    # Removes any duplicate units registered
+    # and sorts all unit lists
+    #
+    # @return [self]
+    def scrub!
+      units.values.map do |items|
+        items.sort!{|x,y| y.version <=> x.version}
+        items.uniq!
+      end
+      self
+    end
+
+  end
+end

data/lib/grimoire/unit.rb

@@ -0,0 +1,14 @@
+require 'grimoire'
+
+module Grimoire
+
+  # Defines a specific unit in the system
+  class Unit < Utility
+
+    attribute :name, String, :required => true
+    attribute :dependencies, DEPENDENCY_CLASS, :multiple => true, :default => [], :coerce => lambda{|val| DEPENDENCY_CLASS.new(val.first, *val.last)}
+    attribute :version, VERSION_CLASS, :required => true, :coerce => lambda{|val| VERSION_CLASS.new(val)}
+
+  end
+
+end

data/lib/grimoire/utility.rb

@@ -0,0 +1,21 @@
+require 'grimoire'
+
+module Grimoire
+
+  # Base class for building utility objects
+  class Utility
+
+    # Provide lazy setup helpers
+    include Bogo::Lazy
+
+    # Disable data state
+    always_clean!
+
+    # Force load on init to enforce rules
+    def initialize(args={})
+      load_data(args)
+    end
+
+  end
+
+end

data/lib/grimoire/version.rb

@@ -0,0 +1,4 @@
+module Grimoire
+  # Current library version
+  VERSION = Gem::Version.new('0.1.0')
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: grimoire
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bogo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.10
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Specialized constraint solver allowing weighted results
+email: code@chrisroberts.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE
+- README.md
+- grimoire.gemspec
+- lib/grimoire.rb
+- lib/grimoire/error.rb
+- lib/grimoire/path.rb
+- lib/grimoire/requirement_list.rb
+- lib/grimoire/solver.rb
+- lib/grimoire/system.rb
+- lib/grimoire/unit.rb
+- lib/grimoire/utility.rb
+- lib/grimoire/version.rb
+homepage: https://github.com/spox/grimoire
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Constraint solver
+test_files: []
+has_rdoc: