elus 0.1.0

data/spec/elus/generator_spec.rb

@@ -0,0 +1,124 @@
+require File.join(File.dirname(__FILE__), ".." ,"spec_helper" )
+
+module Elus
+  include ElusTest
+  
+  shared_examples_for 'all generators' do
+    it 'should generate rules array' do
+      generator = described_class.new
+      rules = generator.generate_rules
+      rules.class.should == Array
+      rules.each {|rule| rule.class.should == Rule} unless rules.empty?
+    end
+  end
+  
+  describe Generator do
+    it_should_behave_like 'all generators' 
+  end
+
+  describe EmptyGenerator do
+    it_should_behave_like 'all generators' 
+
+    it 'should generate empty rules set' do
+      generator = EmptyGenerator.new
+      generator.generate_rules.should == []
+    end
+  end
+
+  describe Turn1Generator do
+    before :each do
+      @generator = Turn1Generator.new
+      @rules = @generator.generate_rules
+    end
+    
+    it_should_behave_like 'all generators' 
+
+    it 'should generate non-empty rules set' do
+      @rules.should_not be_empty
+    end
+
+    it 'should generate rules with Any condition and without "no" branch' do
+      @rules.each do |rule|
+        rule.name.should =~ /If last Piece is Any Piece/
+        rule.name.should_not =~ /otherwise/
+      end
+    end
+
+    it 'should generate only rules with valid(.X.) Pieces in "yes" branch' do
+      @rules.count.should == 12
+      permutate do |code|
+        piece = Piece.create(code)
+        re = Regexp.new(', ' + piece.name + ' Piece is next')
+        @rules.count {|rule| rule.name =~ re}.should == 1
+      end
+    end
+  end
+
+  describe Turn2Generator do
+    before :each do
+      @generator = Turn2Generator.new
+      @rules = @generator.generate_rules
+    end
+    
+    it_should_behave_like 'all generators' 
+
+    it 'should generate non-empty rules set' do
+      @rules.should_not be_empty
+    end
+
+    it 'should generate rules without Any condition and with obligatory "no" branch' do
+      @rules.each do |rule|
+        rule.name.should_not =~ /If last Piece is Any Piece/
+        rule.name.should =~ /otherwise/
+      end
+    end
+
+    it 'should generate only rules with opposite yes-no branches' do
+      @rules.count.should == 36
+      permutate('1') do |cond_code|
+        cond = Piece.create(cond_code)
+        permutate do |yes_code|
+          yes = Piece.create(yes_code)
+          no = Piece.create(Piece.different(yes_code))
+          re = Regexp.new("If last Piece is #{cond.name} Piece, #{yes.name} Piece is next, otherwise #{no.name} Piece is next")
+          @rules.count {|rule| rule.name =~ re}.should == 1
+        end
+      end
+    end
+  end
+
+  describe Turn3Generator do
+    before :each do
+      @generator = Turn3Generator.new
+      @rules = @generator.generate_rules
+    end
+    
+    it_should_behave_like 'all generators' 
+
+    it 'should generate non-empty rules set' do
+      @rules.should_not be_empty
+    end
+
+    it 'should generate rules without Any condition and with obligatory "no" branch' do
+      @rules.each do |rule|
+        rule.name.should_not =~ /If last Piece is Any Piece/
+        rule.name.should =~ /otherwise/
+      end
+    end
+
+    it 'should generate rules with all possible yes-no branches' do
+      @rules.count.should == 432
+      permutate('1') do |cond_code|
+        cond = Piece.create(cond_code)
+        permutate do |yes_code|
+          yes = Piece.create(yes_code)
+          permutate do |no_code|
+            no = Piece.create(no_code)
+            re = Regexp.new("If last Piece is #{cond.name} Piece, #{yes.name} Piece is next, otherwise #{no.name} Piece is next")
+            @rules.count {|rule| rule.name =~ re}.should == 1
+          end
+        end
+      end
+    end
+  end
+end

data/spec/elus/piece_spec.rb

@@ -0,0 +1,190 @@
+require File.join(File.dirname(__FILE__), ".." ,"spec_helper" )
+
+module Elus
+  include ElusTest
+
+  describe Piece do
+    context "creating" do
+      it "should raise error if new method is called" do
+        CODES.each_key do |code|
+          lambda{Piece.new(code)}.should raise_error(NoMethodError)
+        end
+        WRONG_CODES.each do |code|
+          lambda{Piece.new(code)}.should raise_error(NoMethodError)
+        end
+      end
+
+      it "should return nil for a wrong code" do
+        WRONG_CODES.each do |code|
+          Piece.create(code).should == nil
+        end  
+        Piece.create(nil).should == nil
+        Piece.create('').should == nil
+        Piece.create(1).should == nil
+        Piece.create(3.14).should == nil
+        Piece.create(:byd).should == nil
+        Piece.create([]).should == nil
+        Piece.create([1,2,3]).should == nil
+        Piece.create({:symb=>'something'}).should == nil
+      end  
+      
+      it "should have code and name consistent with an input code" do
+        CODES.each do |code, name|
+          Piece.create(code).name.should == name
+          Piece.create(code).code.should == Piece.convert_code(code)
+        end
+      end
+      
+      it "should drop irrelevant characters from code" do
+        Piece.create('b y d ').name.should == BYD
+        Piece.create('yfdzb').name.should == BYD
+        Piece.create('AEFHIJKLMNOPQTUVWXZaefhijklmnopqtuvwxz byd').name.should == BYD
+        Piece.create('byd23456789~@#$%^&*()_+-?><{}[],|/`').name.should == BYD
+      end
+      
+      it "should drop duplicate characters from code" do
+        Piece.create('byyd').name.should == BYD
+        Piece.create('DDyb').name.should == BYD
+        Piece.create('AEFHIJbbbbbbbbbbbbbbbbbbbbyd').name.should == BYD
+        Piece.create('byddd').name.should == BYD
+        Piece.create('byrd').name.should == BYD
+        Piece.create('bydrrdrrrrdr').name.should == BYD
+      end
+      
+      it "should sort code letter if they are given in wrong order" do
+        Piece.create('ydb').name.should == BYD
+        Piece.create('ybd').name.should == BYD
+        Piece.create('dBy').name.should == BYD
+        Piece.create('Dby').name.should == BYD
+        Piece.create('dyb').name.should == BYD
+        Piece.create('Bdy').name.should == BYD
+      end
+      
+      it "should not sort code letter mixed with numbers or specials but return nil" do
+        Piece.create('1dy').should == nil
+        Piece.create('d1b').should == nil
+        Piece.create('yb0').should == nil
+        Piece.create('!dy').should == nil
+        Piece.create('d=b').should == nil
+        Piece.create('yb.').should == nil
+      end
+      
+      it "should create Pieces from codes with special meaning" do
+        SPECIAL_CODES.each do |code, name|
+          Piece.create(code).name.should == name
+        end
+      end
+    end
+  
+    context 'comparing' do
+      it 'should match its code, self and Piece with the same code' do
+       (CODES.merge SPECIAL_CODES).each do |code, name|
+          piece1 = Piece.create(code)
+          piece2 = Piece.create(code)
+          should_be_equal(piece1, code)
+          should_be_equal(piece1, piece1)
+          should_be_equal(piece1, piece2)
+        end
+      end
+      
+      it 'should be reciprocal' do
+       all_chars_twice do |code1, code2|
+          piece1 = Piece.create(code1)
+          piece2 = Piece.create(code2)
+          should_be_equal(piece2, piece1) if piece1 == piece2
+          should_be_equal(piece1, piece2)  if piece2 == piece1
+        end
+      end
+      
+      it 'should match dots in all positions' do
+        all_chars do |code|
+          c1,c2,c3 = code.split(//)
+          piece = Piece.create(c1+c2+c3)
+           should_be_equal(piece, '.'+c2+c3)
+           should_be_equal(piece,  Piece.create('.'+c2+c3))
+           should_be_equal(Piece.create('.'+c2+c3),  piece)
+           should_be_equal(piece,  c1+'.'+c3)
+           should_be_equal(piece,  Piece.create(c1+'.'+c3))
+           should_be_equal(Piece.create(c1+'.'+c3),  piece)
+           should_be_equal(piece,  c1+c2+'.')
+           should_be_equal(piece,  Piece.create(c1+c2+'.'))
+           should_be_equal(Piece.create(c1+c2+'.'),  piece)
+       end
+      end
+      it 'should support eql? comparison (based on code)' do
+       all_chars_twice do |code1, code2|
+          piece1 = Piece.create(code1)
+          piece2 = Piece.create(code2)
+          (piece1.eql? piece2).should be_true if piece1.code == piece2.code
+          (piece2.eql? piece1).should be_true if piece1.code == piece2.code
+        end
+      end
+
+      it "should be bigger than nil" do
+       all_chars('01=!.') do |code|
+       (Piece.create(code) > nil).should be_true
+        end
+      end
+    end
+    
+    context 'multiplying Piece by mask (finding next Piece)' do
+      it 'should copy mask if the mask contains only numbers OR dots' do
+        all_chars_twice('01.=!', '01.') do |code1, code2|
+            piece = Piece.create(code1)
+            mask = Piece.create(code2)
+            should_be_equal(piece * mask, mask)
+        end  
+      end
+  
+      it 'should convert mask if mask contains special chars' do
+        all_chars_twice do |orig_code, mask_code|  
+          expected = []
+          mask_code.split(//).each_with_index do |char,i|
+            expected[i] = case char
+                            when '0' then '0'
+                            when '1' then '1'
+                            when '.' then '.'
+                            when '=' then orig_code[i]
+                            when '!' then Piece.different(orig_code[i])
+                          end
+          end
+            expected_code = expected.join('')
+            piece = Piece.create(orig_code)
+            mask = Piece.create(mask_code)
+            should_be_equal(piece * mask, expected_code)
+            should_be_equal(piece * mask, Piece.create(expected_code))
+        end
+      end
+    end
+
+    context 'assorted class methods' do
+      it 'should be able to return universal (Any) Piece' do
+        any = Piece.any
+        any.name.should == 'Any'
+        all_chars do |code|
+          piece = Piece.create(code)
+          should_be_equal(piece, any)
+          (piece * any).name.should == 'Any'
+        end
+      end
+  
+      it 'should be able to convert code to different (opposite)' do
+        all_chars do |code|  
+          expected = []
+          code.split(//).each_with_index do |char,i|
+            expected[i] = case char
+                            when '0' then '1'
+                            when '1' then '0'
+                            when '.' then '.'
+                            when '=' then '!'
+                            when '!' then '='
+                          end
+          end
+          expected_code = expected.join('')
+          Piece.different(code).should == expected_code
+        end
+      end
+    end
+
+  end
+end

data/spec/elus/rule_spec.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), ".." ,"spec_helper" )
+
+module Elus
+  include ElusTest
+
+  describe Rule do
+    context 'creating' do
+      it 'should create appropriate Rules given correct arguments' do
+        RULES.each do |args, name|
+          rule = Rule.new(*args)
+          rule.name.should == name
+        end
+      end
+      it 'should fail if given wrong arguments' do
+        WRONG_RULES.each do |args|
+          lambda{Rule.new(*args)}.should raise_error(Invalid)
+        end
+      end
+    end
+    context 'applying Rule to Pieces' do
+      it 'should produce expected outcome when applied to any Piece' do
+        all_chars_twice('01.') do |piece, condition|
+          p =  Piece.create(piece)
+          c =  Piece.create(condition)
+          random_chars_twice 100 do |yes, no|
+            y =  Piece.create(yes)
+            n =  Piece.create(no)
+            rule = Rule.new(c, y, n)
+            if p == c
+              should_be_equal(rule.apply(p), p * y)
+            else  
+              should_be_equal(rule.apply(p), p * n)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/elus/solver_spec.rb

@@ -0,0 +1,203 @@
+require File.join(File.dirname(__FILE__), ".." ,"spec_helper" )
+
+module Elus
+  include ElusTest
+  
+  def create_solver(options={})
+    @stdout = options[:stdout] || mock('stdout').as_null_object
+    @stdin = options[:stdin] || mock('stdin')
+    @stdin.stub(:gets).and_return(*options[:input]) if options[:input]
+    @solver = Solver.new(@stdin, @stdout)
+  end
+  
+  def start_solver(options={})
+    create_solver(options)
+    @solver.start(options[:generator] || stub('generator', :generate_rules => []))
+  end
+
+  # sets expectation for stdout to receive strictly ordered sequence of exact messages
+  def stdout_should_receive(*messages)
+    messages.each do |message|
+      @stdout.should_receive(:puts).with(message).once.ordered
+    end
+  end
+
+  # sets expectation for stdout to receive message(s) containing all of the patterns (unordered)
+  def stdout_should_include(*patterns)
+    patterns.each do |pattern|
+      re = Regexp === pattern ? pattern : Regexp.new(Regexp.escape(pattern))
+      @stdout.should_receive(:puts).with(re).at_least(:once)
+    end
+  end
+ 
+  describe Solver do  
+    context 'starting up' do
+      it 'should send a welcome message' do
+        create_solver
+        stdout_should_receive("Welcome to Elus Solver!")
+        @solver.start(stub('generator', :generate_rules => []))
+      end
+      
+      it 'should prompt for Game state' do
+        create_solver
+        stdout_should_receive("Enter Game state:")
+        @solver.start(stub('generator', :generate_rules => []))
+      end
+    end
+  
+    context 'inputing single Piece' do
+      it 'should return corresponding Piece for each correct code entered' do
+        CODES.each do |code, name|
+          start_solver
+          @stdin.stub(:gets).and_return(code)
+          piece = @solver.input_piece
+          piece.name.should == name
+        end
+      end
+      it 'should inform about invalid codes and return nil if interrupted' do
+        WRONG_CODES.each do |code|
+          start_solver
+          @stdin.stub(:gets).and_return(code, "\n")
+          stdout_should_receive("Invalid code: #{code}")
+          @solver.input_piece.should == nil
+        end
+      end
+    end
+    
+#    context 'inputing Game state as a codestring' do
+#      it 'should ignore wrong piece codes' do
+#        WRONG_CODES.each do |code|
+#          start_solver
+#          stdout_should_receive("Free:\n#{BYD}\n#{BYD}\n#{BYD}\nBoard:\n#{BYD}\n#{BYD}\n#{BYD}\n")
+#          @solver.input_state(code+"\n"+"BYD\n"*6)
+#        end
+#      end
+#      it 'should output matching Piece name' do
+#        CODES.each do |code, name|
+#          start_solver
+#          stdout_should_include(name)
+#          @solver.input_state("#{code}\n"+"BYD\n"*5)
+#        end
+#      end
+#      it 'should raise exception if not enough Pieces' do
+#        (0..5).each do |n| 
+#          start_solver
+#          lambda{@solver.input_state("BYD\n"*n)}.should raise_error(Invalid)
+#        end  
+#      end
+#      it 'should output correct Game state' do
+#        CODES.each do |code, name|
+#            start_solver
+#            stdout_should_receive("Free:\n#{name}\n#{BYD}\n#{BYD}\nBoard:\n#{BYD}\n#{BYD}\n#{BYD}\n")
+#            @solver.input_state("#{code}\n#"+"BYD\n"*5)
+#        end
+#      end
+#    end
+
+    context 'inputing Game state from stdin' do
+      it 'should report wrong piece codes' do
+        WRONG_CODES.each do |code|
+          start_solver(:input => ["BYD\n", "BYD\n", "BYD\n", "BYD\n", "BYD\n", "BYD\n", code+"\n", "\n"])
+          stdout_should_receive("Invalid code: #{code}\n")
+          @solver.input_state
+        end
+      end
+      it 'should output matching Piece name' do
+        CODES.each do |code, name|
+          start_solver(:input => [code+"\n", "BYD\n", "BYD\n", "BYD\n", "BYD\n", "BYD\n", "\n"])
+          stdout_should_include(name)
+          @solver.input_state
+        end
+      end
+      it 'should raise exception if not enough Pieces' do
+        (0..5).each do |n| 
+          start_solver(:input => [* Array.new(n,"BYD\n") << "\n"])
+          lambda{@solver.input_state}.should raise_error(Invalid)
+        end  
+      end
+      it 'should output prompts, separate piece feedback and then correct Game state' do
+        CODES.each do |code, name|
+          start_solver(:input => [code+"\n", "BYD\n", "BYD\n", "BYD\n", "BYD\n", "BYD\n", "\n"])
+          stdout_should_receive("Enter Free Piece code (1):", "You entered Free Piece (1): #{name}", 
+                                "Enter Free Piece code (2):", "You entered Free Piece (2): #{BYD}",
+                                "Enter Free Piece code (3):", "You entered Free Piece (3): #{BYD}",
+                                "Enter Board Piece code (1):", "You entered Board Piece (1): #{BYD}",
+                                "Enter Board Piece code (2):", "You entered Board Piece (2): #{BYD}",
+                                "Enter Board Piece code (3):", "You entered Board Piece (3): #{BYD}")
+          @solver.input_state
+        end
+      end
+    end
+    
+    context 'showing state/hints' do
+      it 'should correctly output Game state before making move' do
+        CODES.each do |code, name|
+          start_solver(:input => [code+"\n", "BYD\n", "BYD\n", "BYD\n", "BYD\n", "BYD\n", "\n"])
+          @solver.input_state
+          stdout_should_receive("Free:\n#{name}\n#{BYD}\n#{BYD}\nBoard:\n#{BYD}\n#{BYD}\n#{BYD}\n")
+          @solver.make_move
+        end
+      end
+      
+      it 'should output zero Rules when making moves in inconsistent (wrong) Game state' do
+        start_solver(:generator => Turn1Generator.new, :input => ["BYD\n", "BYD\n", "BYD\n", "BYD\n", "BYD\n", "BYD\n", "BYD\n", "\n"])
+        stdout_should_include(/Rules\(0\):\s*Moves\(0\):/)
+        @solver.input_state
+        @solver.make_move
+      end
+      
+      it 'should output possible game Rules wheh given correct Game state' do
+        start_solver(:generator => Turn1Generator.new, :input => ["BGC\n", "sgd\n", "syc\n", "BYD\n", "SYD\n", "BGD\n", "\n"])
+        stdout_should_include \
+"Rules(2):
+If last Piece is Any Piece, Diamond Piece is next
+If last Piece is Any Piece, Same shape Piece is next
+Moves(1):
+Small Green Diamond(2)"
+        @solver.input_state
+        @solver.make_move
+      end
+    end
+    
+    context 'making move' do
+      it 'should prompt to make move' do
+        start_solver(:generator => Turn1Generator.new, :input => ["BGC\n", "sgd\n", "syc\n", "BYD\n", "SYD\n", "BGD\n", "\n"])
+        stdout_should_include("Make your move:")
+        @solver.input_state
+        @solver.make_move
+      end
+
+      it 'should output move feedback for incorrect move (invalid code, interrupt)' do
+        start_solver(:generator => Turn1Generator.new, :input => ["BGC\n", "sgd\n", "syc\n", "BYD\n", "SYD\n", "BGD\n", "\n"])
+        @solver.input_state 
+        @stdin.stub(:gets).and_return("Saa","\n","SYC","SYD","BYC")
+        stdout_should_include("Make your move:", "Wrong move (no piece given)")
+        @solver.make_move
+      end
+
+      it 'should output move feedback for incorrect move (valid code, but not in free set)' do
+        start_solver(:generator => Turn1Generator.new, :input => ["BGC\n", "sgd\n", "syc\n", "BYD\n", "SYD\n", "BGD\n", "\n"])
+        @solver.input_state 
+        @stdin.stub(:gets).and_return("BGD","N","SYC","SYD","BYC")
+        stdout_should_include("Make your move:", "Wrong move (not in free set): Big Green Diamond")
+        @solver.make_move
+      end
+
+      it 'should output move feedback for right move' do
+        start_solver(:generator => Turn1Generator.new, :input => ["BGC\n", "sgd\n", "syc\n", "BYD\n", "SYD\n", "BGD\n", "\n"])
+        @solver.input_state 
+        @stdin.stub(:gets).and_return("SGD","Y","SYC","SYD","BYC")
+        stdout_should_include("Make your move:", "You moved: Small Green Diamond", "Was the move right(Y/N)?:", "Great, now enter new Free set:")
+        @solver.make_move
+      end
+
+      it 'should output move feedback for wrong move' do
+        start_solver(:generator => Turn1Generator.new, :input => ["BGC\n", "sgd\n", "syc\n", "BYD\n", "SYD\n", "BGD\n", "\n"])
+        @solver.input_state 
+        @stdin.stub(:gets).and_return("SYC","N")
+        stdout_should_include("Make your move:", "You moved: Small Yellow Circle", "Was the move right(Y/N)?:", "Too bad")
+        @solver.make_move
+      end
+    end
+  end
+end