elus 0.1.0

data/lib/elus.rb

@@ -0,0 +1,5 @@
+require 'elus/game'
+require 'elus/generator'
+require 'elus/piece'
+require 'elus/rule'
+require 'elus/solver'

data/lib/elus/game.rb

@@ -0,0 +1,74 @@
+module Elus
+  class Game
+    def initialize(options = {})
+      rules_generator = options[:generator]
+      @board = options[:board]
+      @free = options[:free]
+      raise Elus::Invalid, "Wrong Board or Free set: #{@board}, #{@free}" unless [@board, @free].all? {|set| Array === set}  # Check if all pieces are correct
+      raise Elus::Invalid, "Wrong Game Pieces: #{@board}, #{@free}" unless (@board + @free).all? {|piece| Piece === piece}  # Check if all pieces are correct
+      raise Elus::Invalid, "Wrong number of Game Pieces: #{@board}, #{@free}" unless @board.size >= 3 and @free.size == 3  # Check for correct Board/Free size
+      raise Elus::Invalid, "Wrong Rules generator" unless rules_generator.respond_to? :generate_rules
+      
+      @rules = rules_generator.generate_rules
+      test_rules
+      count_moves
+    end
+    
+    # Count Moves
+    def count_moves
+      @moves = @free.map do |piece| 
+        count = @rules.count {|rule| piece == rule.apply(@board.last)}
+        count > 0 ? "#{piece.name}(#{count})" : nil
+      end.compact
+    end
+    
+    def move(piece, new_free=nil)
+      if new_free # The move was right!
+        @board << piece
+        @free = new_free
+      else
+        @free.delete(piece)
+      end  
+      test_rules
+      count_moves
+    end
+    
+    def state
+      "Free:\n" + @free.join("\n") + "\nBoard:\n" + @board.join("\n") + "\n"
+    end
+
+    def hint
+      "Rules(#{@rules.size}):\n" + @rules.map(&:name).join("\n") +"\n" +
+      "Moves(#{@moves.size}):\n" + @moves.join("\n") + "\n"
+    end
+    
+    def finished? 
+      @board.size>=8  
+    end
+    
+    def valid_move? piece 
+      @free.include? piece
+    end
+    private 
+    
+    # Tests rules against current Game state, drops inconsistent rules
+    def test_rules
+      # Drop rule if not consistent with the Board sequence
+      @rules.delete_if do |rule| 
+        @board.each_cons(2).to_a.inject(false) do |delete, pieces|
+          delete or rule.apply(pieces.first)!=pieces.last
+        end
+      end
+
+      # Drop rule if applied to last Board Piece does not have single match among Free Pieces
+      @rules.delete_if do |rule| 
+        @free.count {|piece| piece == rule.apply(@board.last)} != 1
+      end
+    end
+
+  end
+  
+  # An exception of this class indicates invalid input
+  class Invalid < StandardError
+  end
+end

data/lib/elus/generator.rb

@@ -0,0 +1,48 @@
+module Elus
+  # Rules Generators
+  class Generator
+    def generate_rules
+      []
+    end
+    
+    # iterates through all permutations of string chars with 2 dots  
+    def permutate(string='01!=')
+      string.split(//).product(['.'],['.']).map {|set| set.permutation.to_a.uniq}.flatten(1).map {|chars| chars.join}
+    end
+  end
+
+  class EmptyGenerator < Generator
+  end
+
+  class Turn1Generator < Generator
+    def generate_rules
+      yes_branches = permutate
+      ['...'].product(yes_branches).map do |condition, yes| 
+        Rule.new(Piece.create(condition), Piece.create(yes))
+      end
+    end
+  end
+
+  class Turn2Generator < Generator
+    def generate_rules
+      conditions = permutate('1')
+      branches = permutate.map {|code| [code, Piece.different(code)]}
+      conditions.product(branches.uniq).map  do |condition, yes_no| 
+        yes,no = yes_no
+        Rule.new(Piece.create(condition), Piece.create(yes), Piece.create(no))
+      end  
+    end
+  end
+
+  class Turn3Generator < Generator
+    def generate_rules
+      conditions = permutate('1')
+      yes_branches = permutate
+      no_branches = permutate
+      conditions.product(yes_branches, no_branches).map  do|condition, yes, no| 
+        Rule.new(Piece.create(condition), Piece.create(yes), Piece.create(no))
+      end  
+    end
+  end
+
+end

data/lib/elus/piece.rb

@@ -0,0 +1,93 @@
+module Elus
+  class Piece
+    # These constants are used for translating between the external string representation of a Game and the internal representation.
+    VALID = "01sbgycdr=!."                    # Valid (meaningful) chars in code string (downcase)
+    SORT = "01stghcdd=!."                     # Special unique chars good for sorting (B)ig->(T)itanic, (Y)ellow->(H)ellow, (R)hombus->(D)iamond
+    FINAL = "010101011=!."                    # Final (place-dependent) representation as 0/1 digits
+    INVALID = Regexp.new "[^#{VALID}]"        # Regexp matching all non-valid chars
+    PATTERN = /^[01st=!.][01gh=!.][01cd=!.]$/ # Correct code pattern for Piece creation
+    # Names for Piece characteristics (based on code)
+    NAMES = [ {'0'=>'Small', '1'=>'Big', '='=>'Same size', '!'=>'Different size'},
+    {'0'=>'Green', '1'=>'Yellow', '='=>'Same color', '!'=>'Different color'},
+    {'0'=>'Circle', '1'=>'Diamond', '='=>'Same shape', '!'=>'Different shape'}  ]
+    
+    attr_reader :code
+    private_class_method :new
+    
+    # Factory method: takes an input string and tries to convert it into valid Piece code. Returns new Piece if successful, otherwise nil
+    def Piece.create(input)
+      return nil unless String === input
+      if input_code = convert_code(input) then new(input_code) else nil end 
+    end
+    
+    # Pre-processes string into valid code for Piece creation
+    def Piece.convert_code(input)
+      # Remove all invalid chars from input and transcode it into sort chars
+      input_code = input.downcase.gsub(INVALID, '').tr(VALID, SORT)
+      # Remove dupes and sort unless code contains digits or special chars (place-dependent)
+      input_code = input_code.scan(/\w/).uniq.sort.reverse.join unless input_code =~ /[01!=.]/ 
+      # Translate sort chars into final chars
+      input_code.tr!(SORT, FINAL) if input_code =~ PATTERN 
+    end
+ 
+   # Finds different (opposite, complimentary) code character
+    def Piece.different(string)
+      string.tr('01!=.', '10=!.')
+    end  
+ 
+   # Returns Any Piece (should be a singleton object)
+    def Piece.any
+      @@any ||= Piece.create('...')  
+    end  
+
+    # Assumes valid code (should be pre-filtered by Piece.create)
+    def initialize(input_code)
+      @code = input_code
+    end
+    
+    # Returns full text name of this Piece
+    def name
+     (0..2).map {|i| NAMES[i][@code[i]]}.compact.join(' ').
+      gsub(Regexp.new('^$'), 'Any').
+      gsub(Regexp.new('Same size Same color Same shape'), 'All Same').
+      gsub(Regexp.new('Different size Different color Different shape'), 'All Different')
+    end
+    
+    def to_s; name end
+    
+    def * (other)
+      new_code = case other
+              when nil then nil
+              when String then self * Piece.create(other)
+              when Piece then
+               (0..2).map do |i| 
+                case other.code[i]
+                  when '=' then code[i]
+                  when '!' then Piece.different code[i]
+                else other.code[i]
+                end
+              end.join
+            else raise(ArgumentError, 'Piece compared with a wrong type')
+            end
+      Piece.create(new_code)
+    end
+    
+    include Comparable
+    
+    def <=> (other)
+      case other
+        when nil then 1
+        when String then self <=> Piece.create(other)
+        when Piece then
+        return 0 if code == other.code
+        return 0 if code =~ Regexp.new(other.code)
+        return 0 if other.code =~ Regexp.new(code)
+      else raise(ArgumentError, 'Piece compared with a wrong type')
+      end
+    end
+    
+    def eql? (other)
+      (Piece === other) ? @code.eql?(other.code) : false
+    end
+  end
+end  

data/lib/elus/rule.rb

@@ -0,0 +1,36 @@
+module Elus
+  class Rule
+    def initialize(condition, yes, no=nil)
+      @condition = Piece === condition ? condition : Piece.create(condition)
+      raise Invalid,  "Wrong condition" unless @condition
+      @yes = Piece === yes ? yes : Piece.create(yes)
+      raise Invalid,  "Wrong yes branch" unless @yes
+      @no = if Piece === no 
+              no 
+            elsif Piece.create(no)
+              Piece.create(no) 
+            elsif no
+              raise( Invalid, "Wrong no branch")
+            else
+              nil
+            end
+    end
+    
+    # Returns full text name of this Rule
+    def name
+      "If last Piece is #{@condition.name} Piece, #{@yes.name} Piece is next" + if @no then ", otherwise #{@no.name} Piece is next" else "" end
+    end
+    
+    def to_s; name end
+    
+    def apply(other)
+      piece = Piece === other ? other : Piece.create(other)
+      return nil unless piece
+      if piece == @condition
+        piece * @yes
+      else
+        piece * @no
+      end
+    end
+  end
+end

data/lib/elus/solver.rb

@@ -0,0 +1,84 @@
+module Elus
+  class Solver
+    attr_reader :game
+    
+    def initialize(stdin, stdout)
+      @stdin = stdin  
+      @stdout = stdout
+    end
+    
+    def start (generator)
+      @generator = generator
+      @stdout.puts "Welcome to Elus Solver!"
+      @stdout.puts "Enter Game state:"
+    end
+    
+    # Inputs Game state either from given code string or interactively (from @stdin)
+    def input_state(codes=nil)
+      if codes
+        pieces = codes.split("\n").map {|code| Piece.create(code)}.compact
+        free=pieces[0..2]
+        board=pieces[3..-1]
+      else  
+        free = input_pieces "Free", 3
+        board = input_pieces "Board"
+      end
+      @game = Game.new(:free=>free, :board=>board, :generator=>@generator)
+    end
+    
+    def input_pieces(label, num=10)
+      pieces = []
+      while pieces.size < num and piece = input_piece(:prompt => "Enter #{label} Piece code (#{pieces.size+1}):") do
+        @stdout.puts "You entered #{label} Piece (#{pieces.size+1}): #{piece.name}"
+        pieces << piece 
+      end
+      pieces
+    end
+    
+    # Inputs single correct code from stdin, returns correct piece or nil if break requested. Rejects wrong codes.
+    def input_piece(options = {})
+      loop do
+        @stdout.puts options[:prompt] || "Enter code:"
+        code = @stdin.gets
+        return nil if code == "\n"
+        if piece = Piece.create(code)
+          return piece
+        else
+          @stdout.puts options[:failure] || "Invalid code: #{code}"
+        end
+      end
+    end
+    
+    def make_moves
+      while not @game.finished?
+        make_move
+      end
+    end  
+      
+    def make_move
+      @stdout.puts @game.state
+      @stdout.puts @game.hint
+      piece = input_piece(:prompt => "Make your move:")
+      if piece and @game.valid_move? piece
+        @stdout.puts "You moved: #{piece.name}"
+        @stdout.puts "Was the move right(Y/N)?:"
+        if @stdin.gets =~ /[Yy]/
+          @stdout.puts "Great, now enter new Free set:"
+          free = input_pieces "Free", 3
+          @game.move piece, free
+        else
+          @stdout.puts "Too bad"
+          @game.move piece
+        end
+      elsif piece
+        @stdout.puts "Wrong move (not in free set): #{piece.name}"
+      else 
+        @stdout.puts "Wrong move (no piece given)"
+      end
+    end
+    
+    def state; @game.state end
+    def hint; @game.hint end
+    
+  end #Solver
+end

data/spec/cucumber/stats_spec.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), ".." ,"spec_helper" )
+require File.join(File.dirname(__FILE__), ".." ,".." ,"features" ,"support" ,"stats" )
+
+module ElusTest
+#  describe Stats do
+#    it 'ignores messages that do not contain relevant data' do
+#      stats = Stats.new ['BYD', 'BYD', 'BYD'], ElusTest::CODES
+#      stats.puts "Small Yellow Diamond"
+#      stats.count_for('BYD').should == 0
+#      stats.count_for('SYD').should == nil
+#    end
+#  end
+end

data/spec/elus/game_spec.rb

@@ -0,0 +1,116 @@
+require File.join(File.dirname(__FILE__), ".." ,"spec_helper" )
+
+module Elus
+  include ElusTest
+  
+  def generator_stub
+    stub('generator', :generate_rules => [])
+  end
+
+  def should_be_in(string, *messages)
+    messages.each do |msg|
+      string.split("\n").should include(msg)
+    end  
+  end
+
+  describe Game do
+    before :each do
+       @free = [ Piece.create("BGC"),
+                 Piece.create("sgd"),
+                 Piece.create("syc") ]
+       @board = [Piece.create("BYD"),
+                 Piece.create("SYD"),
+                 Piece.create("BGD") ]
+       @pieces = @free + @board
+       @new =   [ Piece.create("BYC"),
+                 Piece.create("BYD"),
+                 Piece.create("SGC") ]
+    end
+
+    context  "creating" do
+      it "should raise exception if not enough Pieces" do
+        lambda{Game.new(:generator=>generator_stub)}.should raise_error(Invalid)
+        lambda{Game.new(:free=>@free, :generator=>generator_stub)}.should raise_error(Invalid)
+        lambda{Game.new(:board=>@board,:generator=>generator_stub)}.should raise_error(Invalid)
+        (0..2).each {|n| lambda{Game.new(:free=>@pieces[0,n], :board=>@board, :generator=>@wrong_generator)}.should raise_error(Invalid)}
+        (0..2).each {|n| lambda{Game.new(:free=>@free, :board=>@pieces[3,n], :generator=>@wrong_generator)}.should raise_error(Invalid)}
+      end
+      
+      it "should raise exception if it is given wrong generator_stub" do
+        lambda{Game.new(:free=>@free, :board=>@board, :generator=>@wrong_generator)}.should raise_error(Invalid)
+      end
+      
+      it "should contain Free, Board and matching Piece name in Game state" do
+        CODES.each do |code, name|
+          code1, name1 = CODES.to_a[rand(CODES.size-1)]
+          free = @pieces[0..1] << Piece.create(code)
+          board = @pieces[2..3] << Piece.create(code1)
+          game = Game.new(:free=>free, :board=>board, :generator=>generator_stub)
+          should_be_in game.state, name, name1, "Free:", "Board:"
+        end
+      end
+    end
+    
+    context 'generating hints' do
+      it "should generate appropriate hints about Rules" do
+        game = Game.new(:free=>@free, :board=>@board, :generator=>Turn1Generator.new)
+        should_be_in game.hint,  'Rules(2):',
+                                  'If last Piece is Any Piece, Diamond Piece is next',
+                                  'If last Piece is Any Piece, Same shape Piece is next'
+      end
+      it "should generate appropriate hints about Moves" do
+        game = Game.new(:free=>@free, :board=>@board, :generator=>Turn1Generator.new)
+        should_be_in game.hint,  'Moves(1):',
+                                 'Small Green Diamond(2)'
+      end
+    end
+    context 'making moves' do
+      it 'should add moved piece to board upon right move' do
+        game = Game.new(:free=>@free, :board=>@board, :generator=>Turn1Generator.new)
+        piece = Piece.create('SGD')
+        game.move(piece, @new)
+        game.state.should =~ Regexp.new("Board:[\\w\\s]*#{piece.name}")
+      end
+      it 'should reset free and moves sets upon right move' do
+        game = Game.new(:free=>@free, :board=>@board, :generator=>Turn1Generator.new)
+        piece = Piece.create('SGD')
+        game.move(piece, @new)
+        game.state.should =~ Regexp.new('Free:\s'+@new.map(&:name).join('\s'))
+        game.hint.should =~ /Moves\(1\):\sBig Yellow Diamond/
+      end
+      it 'should not add moved piece to board upon wrong move' do
+        game = Game.new(:free=>@free, :board=>@board, :generator=>Turn1Generator.new)
+        piece = Piece.create('BGC')
+        game.move(piece)
+        game.state.should_not =~ Regexp.new("Board:[\\w\\s]*#{piece.name}")
+      end
+      it 'should remove moved piece from free set upon wrong move' do
+        game = Game.new(:free=>@free, :board=>@board, :generator=>Turn1Generator.new)
+        piece = Piece.create('BGC')
+        game.move(piece)
+        game.state.should_not =~ Regexp.new('Free:[\s.]*'+piece.name+'[\s.]Board')
+        game.hint.should =~ /Moves\(1\):\sSmall Green Diamond/
+      end
+    end
+    context 'predicate testing' do
+      it 'should be finished if more than 8 pieces on the board' do
+        game = Game.new(:free=>@free, :board=>@board+@board+@board, :generator=>Turn1Generator.new)
+        game.should be_finished
+      end
+      it 'should consider any free piece a valid move' do
+        ['BGC', 'SGD', 'SYC'].each do |code|
+          game = Game.new(:free=>@free, :board=>@board, :generator=>Turn1Generator.new)
+          piece = Piece.create(code)
+          game.should be_valid_move(piece)
+        end
+      end
+      it 'should not consider any non-free piece a valid move' do
+        CODES.each do |code, name|
+          game = Game.new(:free=>@free, :board=>@board, :generator=>Turn1Generator.new)
+          piece = Piece.create(code)
+          game.should_not be_valid_move(piece) unless @free.include? piece
+        end
+      end
+    end
+  end
+end