winston 0.0.2 → 0.1.0

data/spec/winston/backtrack_spec.rb

@@ -1,6 +1,6 @@
 require "winston"
 
-describe Winston::Backtrack do
+describe Winston::Solvers::Backtrack do
   let(:csp) { Winston::CSP.new }
   subject { described_class.new(csp) }
 
@@ -44,5 +44,38 @@ describe Winston::Backtrack do
         end
       end
     end
+
+    context "with heuristics" do
+      it "uses MRV to pick the smallest remaining domain first" do
+        csp.add_variable :a, domain: [1, 2, 3]
+        csp.add_variable :b, domain: [1]
+        csp.add_variable :c, domain: [1, 2]
+
+        solver = described_class.new(csp, variable_strategy: :mrv)
+        result = solver.search
+
+        expect(result.keys).to eq([:b, :c, :a])
+      end
+
+      it "uses LCV to prefer values that leave more options" do
+        csp.add_variable :a, domain: [2, 1]
+        csp.add_variable :b, domain: [2, 3]
+        csp.add_constraint(:a, :b) { |a, b| b > a }
+
+        solver = described_class.new(csp, value_strategy: :lcv)
+        result = solver.search
+
+        expect(result[:a]).to eq(1)
+      end
+
+      it "supports forward checking" do
+        csp.add_variable :a, domain: [1]
+        csp.add_variable :b, domain: [1]
+        csp.add_constraint(:a, :b) { |a, b| a != b }
+
+        solver = described_class.new(csp, forward_checking: true)
+        expect(solver.search).to be(false)
+      end
+    end
   end
 end

data/spec/winston/csp_spec.rb

@@ -87,8 +87,32 @@ describe Winston::CSP do
     end
 
     it "should pass a collection of preset variables to the solver" do
-      expect(solver).to receive(:search).with(a: 1)
+      expect(solver).to receive(:search).with({ a: 1 })
       subject.solve(solver)
     end
+
+    it "builds a solver by name with options" do
+      subject.add_constraint(:a, :b) { |a, b| a < b }
+      result = subject.solve(:backtrack, variable_strategy: :mrv)
+
+      expect(result).to eq({ a: 1, b: 2 })
+    end
+
+    it "raises for an unknown solver name" do
+      expect { subject.solve(:unknown) }.to raise_error(ArgumentError, /Unknown solver/)
+    end
+
+    it "returns false when preset assignments violate a constraint" do
+      subject.add_constraint(:a) { |a| a > 2 }
+      expect(solver).to_not receive(:search)
+      expect(subject.solve(solver)).to be(false)
+    end
+
+    it "returns false when a constraint among preset variables is violated" do
+      subject.add_variable :c, value: 2
+      subject.add_constraint(:a, :c) { |a, c| a == c }
+      expect(solver).to_not receive(:search)
+      expect(subject.solve(solver)).to be(false)
+    end
   end
 end

data/spec/winston/dsl_spec.rb

@@ -0,0 +1,71 @@
+require "winston"
+
+describe Winston::DSL do
+  describe ".define" do
+    it "builds a CSP with variables and constraints" do
+      csp = Winston.define do
+        var :a, domain: [1, 2, 3]
+        var :b, domain: [1, 2, 3]
+        constraint(:a, :b) { |a, b| a > b }
+      end
+
+      expect(csp.solve).to eq({ a: 2, b: 1 })
+    end
+
+    it "supports named domains" do
+      csp = Winston.define do
+        domain :digits, [1, 2, 3]
+        var :a, domain: :digits
+        var :b, domain: :digits
+        constraint(:a, :b) { |a, b| a != b }
+      end
+
+      result = csp.solve
+      expect([1, 2, 3]).to include(result[:a])
+      expect([1, 2, 3]).to include(result[:b])
+      expect(result[:a]).to_not eq(result[:b])
+    end
+
+    it "uses named constraints via use_constraint" do
+      csp = Winston.define do
+        var :a, domain: [1, 2]
+        var :b, domain: [1, 2]
+        use_constraint :all_different, :a, :b
+      end
+
+      expect(csp.solve).to eq({ a: 1, b: 2 })
+    end
+
+    it "passes options to named constraints" do
+      csp = Winston.define do
+        var :a, domain: [1, 2, 3]
+        use_constraint :not_in_list, :a, list: [1, 2]
+      end
+
+      expect(csp.solve).to eq({ a: 3 })
+    end
+  end
+
+  describe ".register_constraint" do
+    it "registers and uses a custom constraint by name" do
+      custom = Class.new(Winston::Constraint) do
+        def validate(assignments)
+          values = values_at(assignments)
+          values.all? { |v| v == 2 }
+        end
+      end
+
+      Winston.register_constraint(:all_twos) do |variables, allow_nil, **_options|
+        custom.new(variables: variables, allow_nil: allow_nil)
+      end
+
+      csp = Winston.define do
+        var :a, domain: [1, 2]
+        var :b, domain: [1, 2]
+        use_constraint :all_twos, :a, :b
+      end
+
+      expect(csp.solve).to eq({ a: 2, b: 2 })
+    end
+  end
+end

data/spec/winston/heuristics_spec.rb

@@ -0,0 +1,47 @@
+require "winston"
+
+describe Winston::Heuristics do
+  let(:csp) { Winston::CSP.new }
+
+  describe ".mrv" do
+    it "picks the variable with the fewest remaining values" do
+      csp.add_variable :a, domain: [1, 2, 3]
+      csp.add_variable :b, domain: [1, 2]
+      csp.add_variable :c, domain: [1, 2, 3]
+      csp.add_constraint(:a) { |a| a == 1 }
+
+      vars = csp.variables.each_value.to_a
+      chosen = described_class.mrv.call(vars, {}, csp)
+
+      expect(chosen.name).to eq(:a)
+    end
+  end
+
+  describe ".lcv" do
+    it "orders values to leave more options for other variables" do
+      csp.add_variable :a, domain: [2, 1]
+      csp.add_variable :b, domain: [2, 3]
+      csp.add_constraint(:a, :b) { |a, b| b > a }
+
+      values = csp.domain_for(:a)
+      ordered = described_class.lcv.call(values, csp.variables[:a], {}, csp)
+
+      expect(ordered).to eq([1, 2])
+    end
+  end
+
+  describe ".in_order" do
+    it "returns values as-is" do
+      values = [3, 1, 2]
+      ordered = described_class.in_order.call(values, nil, {}, csp)
+
+      expect(ordered).to eq(values)
+    end
+  end
+
+  describe ".forward_checking" do
+    it "returns true to enable forward checking" do
+      expect(described_class.forward_checking).to be(true)
+    end
+  end
+end

data/spec/winston/mac_spec.rb

@@ -0,0 +1,44 @@
+require "winston"
+
+describe Winston::Solvers::MAC do
+  let(:csp) { Winston::CSP.new }
+
+  def valid_solution?(csp, assignments)
+    csp.constraints.all? { |constraint| constraint.validate(assignments) }
+  end
+
+  it "solves a simple constraint problem" do
+    csp.add_variable :a, domain: [1, 2, 3]
+    csp.add_variable :b, domain: [1, 2, 3]
+    csp.add_variable :c, domain: [1, 2, 3]
+    csp.add_constraint(:a, :b) { |a, b| a > b }
+    csp.add_constraint(:b, :c) { |b, c| b > c }
+
+    solver = described_class.new(csp)
+    result = solver.search
+
+    expect(result).to be_a(Hash)
+    expect(valid_solution?(csp, result)).to be(true)
+  end
+
+  it "respects preset assignments" do
+    csp.add_variable :a, value: 2
+    csp.add_variable :b, domain: [1, 2, 3]
+    csp.add_constraint(:a, :b) { |a, b| a > b }
+
+    solver = described_class.new(csp)
+    result = solver.search
+
+    expect(result[:a]).to eq(2)
+    expect(valid_solution?(csp, result)).to be(true)
+  end
+
+  it "returns false when constraints are impossible" do
+    csp.add_variable :a, domain: [1]
+    csp.add_variable :b, domain: [1]
+    csp.add_constraint(:a, :b) { |a, b| a != b }
+
+    solver = described_class.new(csp)
+    expect(solver.search).to be(false)
+  end
+end

data/spec/winston/min_conflicts_spec.rb

@@ -0,0 +1,44 @@
+require "winston"
+
+describe Winston::Solvers::MinConflicts do
+  let(:csp) { Winston::CSP.new }
+
+  def valid_solution?(csp, assignments)
+    csp.constraints.all? { |constraint| constraint.validate(assignments) }
+  end
+
+  it "finds a valid solution for a simple problem" do
+    csp.add_variable :a, domain: [1, 2, 3]
+    csp.add_variable :b, domain: [1, 2, 3]
+    csp.add_variable :c, domain: [1, 2, 3]
+    csp.add_constraint(:a, :b) { |a, b| a > b }
+    csp.add_constraint(:b, :c) { |b, c| b > c }
+
+    solver = described_class.new(csp, max_steps: 1_000, random: Random.new(1))
+    result = solver.search
+
+    expect(result).to be_a(Hash)
+    expect(valid_solution?(csp, result)).to be(true)
+  end
+
+  it "respects preset assignments" do
+    csp.add_variable :a, value: 2
+    csp.add_variable :b, domain: [1, 2, 3]
+    csp.add_constraint(:a, :b) { |a, b| a > b }
+
+    solver = described_class.new(csp, max_steps: 1_000, random: Random.new(1))
+    result = solver.search
+
+    expect(result[:a]).to eq(2)
+    expect(valid_solution?(csp, result)).to be(true)
+  end
+
+  it "returns false when no solution is found within max_steps" do
+    csp.add_variable :a, domain: [1]
+    csp.add_variable :b, domain: [1]
+    csp.add_constraint(:a, :b) { |a, b| a != b }
+
+    solver = described_class.new(csp, max_steps: 10, random: Random.new(1))
+    expect(solver.search).to be(false)
+  end
+end

data/winston.gemspec

@@ -1,19 +1,20 @@
 Gem::Specification.new do |gem|
   gem.name        = 'winston'
-  gem.version     = '0.0.2'
+  gem.version     = '0.1.0'
   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.description = 'A small, practical CSP library for Ruby with multiple solvers, heuristics, and a DSL.'
   gem.license     = 'MIT'
+  gem.required_ruby_version = ">= 3.0"
 
   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'
+  gem.add_development_dependency "bundler", "~> 2.4", ">= 2.4.22"
+  gem.add_development_dependency "rake", "~> 13.1"
+  gem.add_development_dependency "rspec", "~> 3.13"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: winston
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - David Michael Nelson
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-02-03 00:00:00.000000000 Z
+date: 2026-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,63 +16,78 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '2.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.22
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '2.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.4.22
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.13'
   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: 
+        version: '3.13'
+description: A small, practical CSP library for Ruby with multiple solvers, heuristics,
+  and a DSL.
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".tool-versions"
 - ".travis.yml"
 - CHANGELOG.md
 - Gemfile
+- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
+- bench/run.rb
 - lib/winston.rb
-- lib/winston/backtrack.rb
 - lib/winston/constraint.rb
 - lib/winston/constraints/all_different.rb
 - lib/winston/constraints/not_in_list.rb
 - lib/winston/csp.rb
 - lib/winston/domain.rb
+- lib/winston/dsl.rb
+- lib/winston/heuristics.rb
+- lib/winston/solvers/backtrack.rb
+- lib/winston/solvers/mac.rb
+- lib/winston/solvers/min_conflicts.rb
 - lib/winston/variable.rb
+- spec/examples/map_coloring_spec.rb
 - spec/examples/numbers_spec.rb
 - spec/examples/sudoku_spec.rb
 - spec/winston/backtrack_spec.rb
@@ -81,13 +96,17 @@ files:
 - spec/winston/constraints/not_in_list_spec.rb
 - spec/winston/csp_spec.rb
 - spec/winston/domain_spec.rb
+- spec/winston/dsl_spec.rb
+- spec/winston/heuristics_spec.rb
+- spec/winston/mac_spec.rb
+- spec/winston/min_conflicts_spec.rb
 - spec/winston/variable_spec.rb
 - winston.gemspec
 homepage: http://github.com/dmnelson/winston
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -95,19 +114,19 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.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: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Constraint Satisfaction Problem (CSP) implementation for Ruby
 test_files:
+- spec/examples/map_coloring_spec.rb
 - spec/examples/numbers_spec.rb
 - spec/examples/sudoku_spec.rb
 - spec/winston/backtrack_spec.rb
@@ -116,4 +135,8 @@ test_files:
 - spec/winston/constraints/not_in_list_spec.rb
 - spec/winston/csp_spec.rb
 - spec/winston/domain_spec.rb
+- spec/winston/dsl_spec.rb
+- spec/winston/heuristics_spec.rb
+- spec/winston/mac_spec.rb
+- spec/winston/min_conflicts_spec.rb
 - spec/winston/variable_spec.rb

data/lib/winston/backtrack.rb

@@ -1,40 +0,0 @@
-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.domain_for(var.name)
-    end
-  end
-end