winston 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b136df3119babb39b3950a0cc96b393d3344453e
+  data.tar.gz: c10c1db2ceda4d4a553b209e7fceb433375eeabd
+SHA512:
+  metadata.gz: d47e3a5f91c608f5c5ad49a649bc9aabf9fd29a243ce0efffa89610a2ba1ad37c68ea026cefbf0b42a1fd0574887af20a50820bd357a0c85f5bd8fe5670ea0a9
+  data.tar.gz: f4a9e5f2c31ef671a50618eb0236d15f59861cf39c2659c980dc34e2e7123f4a84eff5c7c4602220ef0da16ca82eb4541050ffbdeadde0b623601e147b848469

data/.gitignore

@@ -0,0 +1,32 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 David Michael Nelson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,130 @@
+# Winston
+
+[Constraint Satisfaction Problem](http://en.wikipedia.org/wiki/Constraint_satisfaction_problem) (CSP) implementation for Ruby. 
+It provides a useful way to solve problems like resource allocation or planning though a set of constraints.
+
+The most common example of usage for CSPs is probably the game [Sudoku](http://en.wikipedia.org/wiki/Sudoku).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'winston'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install winston
+
+## Usage
+
+The problem consists of three sets of information: Domain, Variables and Constraints. It will try to determine a value
+from the given domain for each variable that will attend all the constraints. 
+
+```ruby
+require 'winston'
+
+csp = Winston::CSP.new
+
+csp.add_variable :a, domain: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+csp.add_variable :b, domain: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+csp.add_variable :c, domain: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+csp.add_constraint(:a, :c) { |a, c| a == c * 2 } # 'a' has to be double of 'c'.
+csp.add_constraint(:a, :b) { |a, b| a > b } # 'a' has to be greater than 'b'.
+csp.add_constraint(:b, :c) { |b, c| b > c } # 'b' has to be greater than 'c'.
+csp.add_constraint(:b) { |b| b % 2 == 0 } # 'b' has to be even.
+
+csp.solve 
+= { a: 6, b: 4, c: 3 }
+```
+
+### Variables and Domain
+
+It's possible to preset values for variables, and in that case the problem would not try to determine values for
+it, but it will take those values into account for validating the constraints.
+
+```ruby
+csp.add_variable "my_var", value: "predefined value"
+```
+
+And it's also possible to set the domain as `Proc` so it'd be evaluated on-demand.
+
+```ruby
+csp.add_variable("other_var") { |var_name, csp| [:a, :b, :c ] } 
+# same as 
+csp.add_variable("other_var", domain: proc { |var_name, csp| [:a, :b, :c ] })
+```
+
+### Constraints
+
+Constraints can be set for specific variables and would be evaluated only when all those variables are set and one
+of them has changed; Or globals, in which case, they'd evaluated for every assignment.
+
+```ruby
+csp.add_constraint(:a) { |a| a > 0 } # positive value
+
+# the last argument passed to the block is always a map of assignments, in other words, the current
+# state of the solution
+
+csp.add_constraint(:a) do |a, assignments| 
+  !assignments.reject { |name, value| name == :a }.values.include?(a) #checks if the value is not present on other variables
+end 
+
+# a global constraint is evaluated for every assignment and the only argument it receives is a
+# hash with all current assignments
+
+csp.add_constraint do |assignments|
+  assignmets.values.uniq.size == assignments.keys.size # checks if every value is unique
+end
+```
+
+Constraint can be also set as their own objects, that's great for reusability.
+
+```ruby
+csp.add_constraint constraint: MyConstraint.new(...)
+# ...
+csp.add_constraint constraint: Winston::Constraints::AllDifferent.new # built-in constraint, checks if all values are different from each other
+```
+
+### Problems without solution
+
+```ruby
+require 'winston'
+
+csp = Winston::CSP.new
+
+csp.add_variable :a, domain: [1, 2]
+csp.add_variable :b, domain: [1, 2]
+csp.add_variable :c, domain: [1, 2]
+
+csp.add_constraint constraint: Winston::Constraints::AllDifferent.new
+
+csp.solve 
+= false
+```
+
+**IMPORTANT NOTE: Depending on the number of variables and the size of the domain it can take a long time to test all different possibilities.
+In that case it'll be recomendable to use of ways to reduce the number of iterations, for example, removing an item from a shared domain
+when it is tested ( A `queue` type of structure, that would `pop` the value on the `each` block).**
+
+### More examples
+
+Check the folder `specs/examples` for more usage examples.
+
+## TODOs / Nice-to-haves
+
+- Create a DSL for setting up the problem
+- Currently only algorithm to solve the CSP is Backtracking, implement other like Local search, Constraint propagation, ...
+- Implement heuristics to improve search time (least constraining value, minimum remaining values,...)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/winston.rb

@@ -0,0 +1,7 @@
+require 'winston/domain'
+require 'winston/variable'
+require 'winston/constraint'
+require 'winston/backtrack'
+require 'winston/csp'
+
+require 'winston/constraints/all_different'

data/lib/winston/backtrack.rb

@@ -0,0 +1,40 @@
+module Winston
+  class Backtrack
+    def initialize(csp)
+      @csp = csp
+    end
+
+    def search(assignments = {})
+      return assignments if complete?(assignments)
+      var = select_unassigned_variable(assignments)
+      domain_values(var).each do |value|
+        assigned = assignments.merge(var.name => value)
+        if valid?(var.name, assigned)
+          result = search(assigned)
+          return result if result
+        end
+      end
+      false
+    end
+
+    private
+
+    attr_reader :csp
+
+    def complete?(assignments)
+      assignments.size == csp.variables.size
+    end
+
+    def valid?(changed, assignments)
+      csp.validate(changed, assignments)
+    end
+
+    def select_unassigned_variable(assignments)
+      csp.variables.reject { |k,v| assignments.include?(k) }.each_value.first
+    end
+
+    def domain_values(var)
+      csp.variables[var.name].domain.values
+    end
+  end
+end

data/lib/winston/constraint.rb

@@ -0,0 +1,19 @@
+module Winston
+  class Constraint
+
+    def initialize(variables = nil, predicate = nil)
+      @variables = variables || []
+      @predicate = predicate
+      @global = @variables.empty?
+    end
+
+    def elegible_for?(changed_var, assignments)
+      @global || (@variables.include?(changed_var) && @variables.all? { |v| assignments.key? v })
+    end
+
+    def validate(assignments)
+      return false unless @predicate
+      @predicate.call(*assignments.values_at(*@variables), assignments)
+    end
+  end
+end

data/lib/winston/constraints/all_different.rb

@@ -0,0 +1,9 @@
+module Winston
+  module Constraints
+    class AllDifferent < Winston::Constraint
+      def validate(assignments)
+        assignments.values.uniq.size == assignments.size
+      end
+    end
+  end
+end

data/lib/winston/csp.rb

@@ -0,0 +1,41 @@
+module Winston
+  class CSP
+
+    attr_reader :variables, :constraints
+
+    def initialize
+      @variables = {}
+      @constraints = []
+    end
+
+    def solve(solver = Backtrack.new(self))
+      solver.search(var_assignments)
+    end
+
+    def add_variable(name, value: nil, domain: nil, &block)
+      domain = Domain.new(self, name, domain || block) unless value
+      variables[name] = Variable.new(name, value: value, domain: domain)
+    end
+
+    def add_constraint(*variables, constraint: nil, &block)
+      constraint ||= Constraint.new(variables, block)
+      constraints << constraint
+    end
+
+    def validate(changed_var, assignments)
+      constraints.each do |constraint|
+        return false if constraint.elegible_for?(changed_var, assignments) && !constraint.validate(assignments)
+      end
+      true
+    end
+
+    private
+
+    def var_assignments
+      @variables.reduce({}) do |assignments, (name, variable)|
+        assignments[name] = variable.value unless variable.value.nil?
+        assignments
+      end
+    end
+  end
+end

data/lib/winston/domain.rb

@@ -0,0 +1,14 @@
+module Winston
+  class Domain
+    def initialize(csp, variable, values)
+      @csp = csp
+      @variable = variable
+      @values = values
+    end
+
+    def values
+      return @values unless @values.is_a?(Proc)
+      @values.call(@variable, @csp)
+    end
+  end
+end

data/lib/winston/variable.rb

@@ -0,0 +1,12 @@
+module Winston
+  class Variable
+    attr_reader :name, :value, :domain
+    attr_writer :value
+
+    def initialize(name, value:, domain:)
+      @name = name
+      @value = value
+      @domain = domain
+    end
+  end
+end

data/spec/examples/numbers_spec.rb

@@ -0,0 +1,38 @@
+require "winston"
+
+describe "Numbers Example" do
+  let(:csp) { Winston::CSP.new }
+
+  describe "'a' has to be double of 'c' and higher than 'b', 'b' has to be even and higher than 'c'" do
+    before do
+      csp.add_variable :a, domain: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      csp.add_variable :b, domain: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      csp.add_variable :c, domain: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+      csp.add_constraint(:a, :c) { |a, c| a == c * 2 }
+      csp.add_constraint(:a, :b) { |a, b| a > b }
+      csp.add_constraint(:b, :c) { |b, c| b > c }
+      csp.add_constraint(:b) { |b| b % 2 == 0 }
+    end
+
+    it "should return a valid solution" do
+      expect(csp.solve).to eq(a: 6, b: 4, c: 3)
+    end
+  end
+
+  describe "has to have different values" do
+    before do
+      csp.add_variable :a, domain: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      csp.add_variable :b, domain: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      csp.add_variable :c, domain: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      csp.add_variable :d, domain: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      csp.add_variable :e, domain: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+      csp.add_constraint constraint: Winston::Constraints::AllDifferent.new
+    end
+
+    it "should return a valid solution" do
+      expect(csp.solve).to eq(a: 1, b: 2, c: 3, d: 4, e: 5)
+    end
+  end
+end

data/spec/winston/backtrack_spec.rb

@@ -0,0 +1,48 @@
+require "winston"
+
+describe Winston::Backtrack do
+  let(:csp) { Winston::CSP.new }
+  subject { described_class.new(csp) }
+
+  describe "#search" do
+    context "simple assigment" do
+      before do
+        csp.add_variable :a, domain: [1, 2, 3, 4]
+        csp.add_variable :b, domain: [1, 2, 3, 4]
+        csp.add_variable :c, domain: [1, 2, 3, 4]
+      end
+
+      it "should assign variables to the first acceptable value" do
+        expect(subject.search).to eq(a: 1, b: 1, c: 1)
+      end
+
+      it "should assign variables to the first acceptable value respecting variables that already have a value" do
+        expect(subject.search(b: 3)).to eq(a: 1, b: 3, c: 1)
+      end
+
+      context "with constraints" do
+        before do
+          csp.add_constraint(:a, :b) { |a,b| a > b }
+          csp.add_constraint(:b, :c) { |b,c| b > c }
+        end
+
+        it "should assign variables to the first acceptable value" do
+          expect(subject.search).to eq(a: 3, b: 2, c: 1)
+        end
+
+        it "should assign variables to the first acceptable value" do
+          expect(subject.search(b: 3)).to eq(a: 4, b: 3, c: 1)
+        end
+
+        it "should return false when it cannot fufill the constraints" do
+          expect(subject.search(c: 3)).to be(false)
+        end
+
+         it "should return false when it cannot fufill the constraints" do
+           csp.add_constraint(:a, :c) { |a,c| a == c * 10 }
+          expect(subject.search).to be(false)
+        end
+      end
+    end
+  end
+end

data/spec/winston/constraint_spec.rb

@@ -0,0 +1,99 @@
+require "winston"
+
+describe Winston::Constraint do
+
+  let(:variables) { nil }
+  let(:predicate) { nil }
+  subject { described_class.new(variables, predicate) }
+
+  describe "#elegible_for?" do
+    context "global" do
+      it "should be elegible for everything" do
+        expect(subject.elegible_for?(:a, {})).to be(true)
+        expect(subject.elegible_for?(:b, { a: 1 })).to be(true)
+      end
+    end
+
+    context "for specific variable" do
+      let(:variables) { [:a] }
+
+      it "should return true when that variable is changed" do
+        expect(subject.elegible_for?(:a, { a: nil })).to be(true)
+      end
+
+      it "should return false when that variable isn't the one changed" do
+        expect(subject.elegible_for?(:b, { a: 1, b: 2 })).to be(false)
+      end
+
+      it "should return false when that variable is changed but doesn't have a value" do
+        expect(subject.elegible_for?(:a, { b: 2 })).to be(false)
+      end
+    end
+
+    context "for multiple variables" do
+      let(:variables) { [:a, :b] }
+
+      it "should return true when one of those variables is changed" do
+        expect(subject.elegible_for?(:a, { a: 1, b: nil })).to be(true)
+      end
+
+      it "should return false when one of those variables isn't the one changed" do
+        expect(subject.elegible_for?(:c, { a: 1, b: 2 })).to be(false)
+      end
+
+      it "should return false when one of those variables is changed but doesn't have a value for every one of them" do
+        expect(subject.elegible_for?(:b, { b: 2 })).to be(false)
+      end
+
+      it "should return false when one of those variables is changed but doesn't have a value for every one of them" do
+        expect(subject.elegible_for?(:a, { b: 2 })).to be(false)
+      end
+    end
+  end
+
+  describe "#validate" do
+    context "no predicate is given" do
+      it "should be considerated invalid" do
+        expect(subject.validate(a: 1)).to be(false)
+      end
+    end
+
+    context "when a predicate is given" do
+      context "on a global constraint" do
+        let(:predicate) do
+          proc { |assignments| assignments[:a] > assignments[:b] }
+        end
+
+        it "should evaluate that predicate" do
+          expect(subject.validate(a: 2, b: 1)).to be(true)
+          expect(subject.validate(a: 1, b: 2)).to be(false)
+        end
+      end
+
+      context "on an unary constraint" do
+        let(:variables) { [:a] }
+        let(:predicate) do
+          proc { |a, assignments| a % 2 == 0 && !assignments.reject { |k,_| k == :a }.values.include?(a) }
+        end
+
+        it "should evaluate that predicate" do
+          expect(subject.validate(a: 2, b: 1)).to be(true)
+          expect(subject.validate(a: 1, b: 2)).to be(false)
+          expect(subject.validate(a: 2, b: 2)).to be(false)
+        end
+      end
+
+      context "on a n-ary constraint" do
+        let(:variables) { [:a, :b, :c] }
+        let(:predicate) do
+          proc { |a, b, c, assignments| a > b && b > c }
+        end
+
+        it "should evaluate that predicate" do
+          expect(subject.validate(a: 2, b: 1, c: 0)).to be(true)
+          expect(subject.validate(a: 1, b: 2, c: 1)).to be(false)
+        end
+      end
+    end
+  end
+end

data/spec/winston/constraints/all_different_spec.rb

@@ -0,0 +1,22 @@
+require "winston"
+
+describe Winston::Constraints::AllDifferent do
+  subject { described_class.new }
+
+  describe "#elegible_for?" do
+    it "should be elegible for everything" do
+      expect(subject.elegible_for?(:a, {})).to be(true)
+      expect(subject.elegible_for?(:b, { a: 1 })).to be(true)
+    end
+  end
+
+  describe "#validate" do
+    it "should return 'true' when all values are unique" do
+      expect(subject.validate(a: 1, b: 2, c: 3, d: 4)).to be(true)
+    end
+
+    it "should return 'false' when not all values are unique" do
+      expect(subject.validate(a: 1, b: 2, c: 2, d: 4)).to be(false)
+    end
+  end
+end

data/spec/winston/csp_spec.rb

@@ -0,0 +1,75 @@
+require "winston"
+
+describe Winston::CSP do
+  subject { described_class.new }
+
+  describe "#add_variable" do
+    let(:domain) { double("Domain") }
+
+    it "should add variable definitions to the problem" do
+      expect(Winston::Domain).to_not receive(:new)
+      subject.add_variable :a, value: 1
+      expect(subject.variables[:a]).to have_attributes(value: 1, domain: nil)
+    end
+
+    it "should add without value and a static domain when it is given" do
+      expect(Winston::Domain).to receive(:new).with(subject, :b, [2, 3]).once.and_return(domain)
+      subject.add_variable :b, domain: [2, 3]
+      expect(subject.variables[:b]).to have_attributes(value: nil, domain: domain)
+    end
+
+    it "should add without value and a dynamic domain when it is given" do
+      expect(Winston::Domain).to receive(:new).with(subject, :c, an_instance_of(Proc)).once
+      subject.add_variable(:c) { |csp| [2, 3, 4] }
+      expect(subject.variables[:c]).to have_attributes(value: nil)
+    end
+  end
+
+  describe "#add_constraint" do
+    let(:constraint) { double("Constraint") }
+    it "should build a constraint for the given block" do
+      expect(Winston::Constraint).to receive(:new).with([:a, :b], an_instance_of(Proc)).once.and_return(constraint)
+      subject.add_constraint(:a, :b) { true }
+      expect(subject.constraints).to include(constraint)
+    end
+
+    it "should add the already build constraint when given" do
+      expect(Winston::Constraint).to_not receive(:new)
+      subject.add_constraint(constraint: constraint)
+      expect(subject.constraints).to include(constraint)
+    end
+  end
+
+  describe "#validate" do
+    it "should return true when there aren't any constraints" do
+      expect(subject.validate(:var, {})).to be(true)
+    end
+
+    it "should return false if one of the constraints returns invalid" do
+      subject.add_constraint(:a) { true }
+      subject.add_constraint(:a) { false }
+
+      expect(subject.validate(:a, {a: 1})).to be(false)
+    end
+
+     it "should not attempt to validate ineligible constraints" do
+      subject.add_constraint(:a) { true }
+      subject.add_constraint(:b) { false }
+
+      expect(subject.validate(:a, { a: 1 , b: 2 })).to be(true)
+    end
+  end
+
+  describe "#solve" do
+    let(:solver) { double("Solver") }
+    before do
+      subject.add_variable :a, value: 1
+      subject.add_variable :b, domain: [1, 2]
+    end
+
+    it "should pass a collection of preset variables to the solver" do
+      expect(solver).to receive(:search).with(a: 1)
+      subject.solve(solver)
+    end
+  end
+end

data/spec/winston/domain_spec.rb

@@ -0,0 +1,35 @@
+require "winston"
+
+describe Winston::Domain do
+  let(:csp) { double("CSP") }
+  let(:variable) { :var }
+
+  subject { described_class.new(csp, variable, values) }
+
+  describe "#values" do
+    context "when given 'values' is a collection" do
+      let(:values) { [1, 2, 3] }
+
+      it "should return that collection" do
+        expect(subject.values).to eq([1, 2, 3])
+      end
+    end
+
+    context "when given 'values' is a proc" do
+      let(:values) do
+        i = 0
+        proc do |given_variable, given_csp|
+          expect(given_variable).to eq(variable)
+          expect(given_csp).to eq(csp)
+
+          [i += 1]
+        end
+      end
+
+      it "should return the result of the evatualtion of that proc" do
+        expect(subject.values).to eq([1])
+        expect(subject.values).to eq([2])
+      end
+    end
+  end
+end

data/spec/winston/variable_spec.rb

@@ -0,0 +1,14 @@
+require "winston"
+
+describe Winston::Variable do
+
+  subject { described_class.new("my_var", value: 1, domain: [1, 2, 3]) }
+
+  it { is_expected.to have_attributes(name: "my_var", value: 1, domain: [1, 2, 3]) }
+
+  describe "#value=" do
+    before { subject.value = "new value" }
+
+    it { is_expected.to have_attributes(value: "new value") }
+  end
+end

data/winston.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |gem|
+  gem.name        = 'winston'
+  gem.version     = '0.0.1'
+  gem.authors     = ['David Michael Nelson']
+  gem.homepage    = 'http://github.com/dmnelson/winston'
+
+  gem.summary     = 'Constraint Satisfaction Problem (CSP) implementation for Ruby'
+  gem.description = gem.summary
+  gem.license     = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "bundler", "~> 1.3"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency 'rspec'
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: winston
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- David Michael Nelson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  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: Constraint Satisfaction Problem (CSP) implementation for Ruby
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/winston.rb
+- lib/winston/backtrack.rb
+- lib/winston/constraint.rb
+- lib/winston/constraints/all_different.rb
+- lib/winston/csp.rb
+- lib/winston/domain.rb
+- lib/winston/variable.rb
+- spec/examples/numbers_spec.rb
+- spec/winston/backtrack_spec.rb
+- spec/winston/constraint_spec.rb
+- spec/winston/constraints/all_different_spec.rb
+- spec/winston/csp_spec.rb
+- spec/winston/domain_spec.rb
+- spec/winston/variable_spec.rb
+- winston.gemspec
+homepage: http://github.com/dmnelson/winston
+licenses:
+- MIT
+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 Satisfaction Problem (CSP) implementation for Ruby
+test_files:
+- spec/examples/numbers_spec.rb
+- spec/winston/backtrack_spec.rb
+- spec/winston/constraint_spec.rb
+- spec/winston/constraints/all_different_spec.rb
+- spec/winston/csp_spec.rb
+- spec/winston/domain_spec.rb
+- spec/winston/variable_spec.rb