sgf_parser 0.1.0

data/spec/sgf/model/event_listener_spec.rb

@@ -0,0 +1,97 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+module SGF
+  module Model
+    describe EventListener do
+      before :each do
+        @listener = EventListener.new
+      end
+      
+      (DefaultEventListener.instance_methods - DefaultEventListener.superclass.instance_methods).each do |method|
+        it "should implement #{method} from SGF::DefaultEventListener" do
+          @listener.methods.should include(method)
+        end
+      end
+      
+      it "should start a new game on start_game" do
+        @listener.start_game
+        game1 = @listener.game
+        @listener.start_game
+        game2 = @listener.game
+        game1.should_not == game2
+      end
+      
+      it "start_variation should create a new node as variation root" do
+        @listener.start_game
+        @listener.start_node
+        node = @listener.node
+        @listener.start_variation
+        @listener.node.should_not == node
+        @listener.node.variation_root?.should be_true
+      end
+      
+      it "end_variation should set current node as parent of current variation's root" do
+        @listener.start_game
+        @listener.start_node
+        node = @listener.node
+        @listener.start_variation
+        @listener.node.should_not == node
+        @listener.end_variation
+        @listener.node.should == node
+      end
+      
+      SGF::Model::GAME_PROPERTY_MAPPINGS.each do |prop_name, attr_name|
+        it "call property_name=#{prop_name} and property_value=something should set #{attr_name} on game" do
+          mock(@listener.game).send(attr_name, '123')
+          @listener.property_name = prop_name
+          @listener.property_value = '123'
+        end
+      end
+
+      it "should set node as game's root node on first call to start_node" do
+        @listener.start_game
+        @listener.start_node
+        @listener.node.should == @listener.game.root_node
+      end
+      
+      it "should create child node on current node when call start_node" do
+        @listener.start_game
+        @listener.start_node
+        node = @listener.node
+        @listener.start_node
+        @listener.node.should_not == node
+        @listener.node.parent.should == node
+        node.children.should == [@listener.node]
+      end
+      
+      it "property_name='C' and property_value=something should add comment to node" do
+        @listener.start_game
+        @listener.start_node
+        @listener.property_name = "C"
+        @listener.property_value = "comment"
+        @listener.game.root_node.comment.should == 'comment'
+      end
+      
+      it "game misc properties" do
+        @listener.start_game
+        @listener.start_node
+        @listener.property_name = "US"
+        @listener.property_value = "A"
+        @listener.game.misc_properties["US"].should == "A"
+        @listener.property_value = "B"
+        @listener.game.misc_properties["US"].should == ["A", "B"]
+      end
+
+      it "node misc properties" do
+        @listener.start_game
+        @listener.start_node
+        @listener.property_name = "TR"
+        @listener.property_value = "AB"
+        @listener.node.misc_properties["TR"].should == "AB"
+        @listener.property_value = "AC"
+        @listener.node.misc_properties["TR"].should == ["AB", "AC"]
+      end
+      
+    end
+  end
+end

data/spec/sgf/model/game_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+module SGF
+  module Model
+    describe Game do
+      it "moves should return number of moves" do
+        game = Game.new
+        n1 = Node.new game.root_node
+        n1.sgf_play_black 'AB'
+        n2 = Node.new n1
+        n2.sgf_play_white 'BC'
+
+        game.moves.should == 2
+      end
+      
+      it "moves should not count non-move nodes" do
+        game = Game.new
+        n1 = Node.new game.root_node
+        n1.sgf_play_black 'AB'
+        dummy1 = Node.new(n1)
+        n2 = Node.new dummy1
+        n2.sgf_play_white 'BC'
+        dummy2 = Node.new(n2)
+
+        game.moves.should == 2
+      end
+    end
+  end
+end

data/spec/sgf/model/node_spec.rb

@@ -0,0 +1,84 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+module SGF
+  module Model
+    describe Node do
+      describe "move_no" do
+        it "should return parent node's move number + 1 if current node is a move" do
+          parent = Node.new
+          mock(parent).move_no{ 10 }
+          node = Node.new(parent)
+          node.sgf_play_black 'AB'
+          node.move_no.should == 11
+        end
+
+        it "should return parent node's move number if current node is not a move" do
+          parent = Node.new
+          mock(parent).move_no{ 10 }
+          node = Node.new(parent)
+          node.move_no.should == 10
+        end
+
+        it "should return 0 if parent is nil and current node is not a move" do
+          node = Node.new
+          node.move_no.should == 0
+        end
+      
+        it "should return 1 if parent is nil and current node is a move" do
+          node = Node.new
+          node.sgf_play_black "AB"
+          node.move_no.should == 1
+        end
+      end
+      
+      it "sgf_setup_black should add an entry to black_moves" do
+        node = Node.new
+        node.sgf_setup_black "AB"
+        node.black_moves.first.should == [0, 1]
+      end
+      
+      it "sgf_setup_white should add an entry to white_moves" do
+        node = Node.new
+        node.sgf_setup_white "AB"
+        node.white_moves.first.should == [0, 1]
+      end
+      
+      it "sgf_play_black should set node type to MOVE and save move information" do
+        node = Node.new
+        node.sgf_play_black "AB"
+        node.node_type.should == Constants::NODE_MOVE
+        node.color.should == Constants::BLACK
+        node.move.should == [0, 1]
+      end
+      
+      it "sgf_play_black should set node type to PASS on empty move coordinate" do
+        node = Node.new
+        node.sgf_play_black "  "
+        node.node_type.should == Constants::NODE_PASS
+        node.color.should == Constants::BLACK
+      end
+      
+      it "sgf_play_white should set node type to MOVE and save move information" do
+        node = Node.new
+        node.sgf_play_white "AB"
+        node.node_type.should == Constants::NODE_MOVE
+        node.color.should == Constants::WHITE
+        node.move.should == [0, 1]
+      end
+      
+      it "sgf_play_white should set node type to PASS on empty move coordinate" do
+        node = Node.new
+        node.sgf_play_white "  "
+        node.node_type.should == Constants::NODE_PASS
+        node.color.should == Constants::WHITE
+      end
+
+      it "child returns first child" do
+        node = Node.new
+        first_child = Node.new(node)
+        second_child = Node.new(node)
+        node.child.should == first_child
+      end
+    end
+  end
+end

data/spec/sgf/more/state_machine_presenter_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../../../lib/sgf/more/state_machine_presenter')
+
+describe SGF::More::StateMachinePresenter do
+  it "should create nodes for start state and all reachable states" do
+    stm = SGF::StateMachine.new(:start)
+    stm.transition(:start, /a/, :state_a)
+
+    presenter = SGF::More::StateMachinePresenter.new
+    presenter.process(stm)
+    
+    presenter.nodes.should include("start")
+    presenter.nodes.should include("state_a")
+  end
+
+  it "should create edges for all transitions" do
+    stm = SGF::StateMachine.new(:start)
+    stm.desc (desc1 = "start + /a/ => state_a")
+    stm.transition(:start, /a/, :state_a)
+    stm.desc (desc2 = "start + /b/ => state_b")
+    stm.transition(:start, /b/, :state_b)
+
+    presenter = SGF::More::StateMachinePresenter.new
+    presenter.process(stm)
+    
+    presenter.edges.should include(["start", "state_a", desc1])
+    presenter.edges.should include(["start", "state_b", desc2])
+  end
+end

data/spec/sgf/parse_error_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module SGF
+  describe ParseError do
+    it "message should return content up to the bad input" do
+      error = ParseError.new("(;AB]", 4)
+      error.message.should include("(;AB] <=== SGF parse error occurred here")
+    end
+  end
+end

data/spec/sgf/parser_spec.rb

@@ -0,0 +1,210 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module SGF
+  describe Parser, 'with DefaultEventListener' do
+    before :each do
+      @listener = DefaultEventListener.new
+      @parser   = Parser.new @listener
+    end
+
+    {'nil' => nil, '' => '', '  ' => '  '}.each do |name, value|
+      it "should throw error on bad input - '#{name}'" do
+        begin
+          @parser.parse(value)
+          fail("Should raise error")
+        rescue => e
+          e.class.should == ArgumentError
+        end
+      end
+    end
+    
+    it "should call start_game" do
+      mock(@listener).start_game
+      @parser.parse("(")
+    end
+    
+    it "should call end_game" do
+      mock(@listener).end_game
+      @parser.parse("(;)")
+    end
+    
+    it "should call start_node" do
+      mock(@listener).start_node
+      @parser.parse("(;")
+    end
+    
+    it "should call end_variation" do
+      mock(@listener).end_variation
+      @parser.parse("(;)")
+    end
+    
+    it "should call property_name= with name" do
+      mock(@listener).property_name = 'GN'
+      @parser.parse("(;GN[)")
+    end
+    
+    it "should call property_value= with value" do
+      mock(@listener).property_value = 'a game'
+      @parser.parse("(;GN[a game])")
+    end
+    
+    it "should call property_value= for each value" do
+      mock(@listener).property_value = 'DB'
+      mock(@listener).property_value = 'KS'
+      @parser.parse("(;AB[DB][KS])")
+    end
+    
+    it "should call start_variation" do
+      mock(@listener).start_variation
+      @parser.parse("(;(")
+    end
+    
+    it "should call end_variation" do
+      mock(@listener).end_variation
+      @parser.parse("(;(;)")
+    end
+  end
+  
+  describe Parser, 'with SGF::Model::EventListener' do
+    before :each do
+      @listener = SGF::Model::EventListener.new
+      @parser   = Parser.new @listener
+    end
+    
+    it "should parse game in file" do
+      @parser.parse_file File.expand_path(File.dirname(__FILE__) + '/../fixtures/good.sgf')
+      game = @listener.game
+      game.name.should == 'White (W) vs. Black (B)'
+      game.rule.should == 'Japanese'
+      game.board_size.should == 19
+      game.handicap.should == 0
+      game.komi.should == 5.5
+      game.played_on.should == "1999-07-28"
+      game.white_player.should == 'White'
+      game.black_player.should == 'Black'
+      game.program.should == 'Cgoban 1.9.2'
+      game.time_rule.should == '30:00(5x1:00)'
+    end
+    
+    it "should raise BinaryFileError on parsing binary file" do
+      pending 'check if file is binary is problematic'
+      lambda {
+        @parser.parse_file File.expand_path(File.dirname(__FILE__) + '/../fixtures/test.png')
+      }.should raise_error(SGF::BinaryFileError)
+    end
+    
+    it "should parse game without moves" do
+      @parser.parse <<-INPUT
+      (;GM[1]FF[3]
+      GN[White (W) vs. Black (B)];
+      )
+      INPUT
+      game = @listener.game
+      game.name.should == 'White (W) vs. Black (B)'
+    end
+    
+    it "should raise error on invalid input" do
+      lambda { @parser.parse("123") }.should raise_error
+    end
+    
+    it "should parse a complete game" do
+      @parser.parse <<-INPUT
+      (;GM[1]FF[3]
+      RU[Japanese]SZ[19]HA[0]KM[5.5]
+      PW[White]
+      PB[Black]
+      GN[White (W) vs. Black (B)]
+      DT[1999-07-28]
+      RE[W+R]
+      SY[Cgoban 1.9.2]TM[30:00(5x1:00)];
+      AW[ea][eb][ec][bd][dd][ae][ce][de][cf][ef][cg][dg][eh][ci][di][bj][ej]
+      AB[da][db][cc][dc][cd][be][bf][ag][bg][bh][ch][dh]LB[bd:A]PL[2]
+      C[guff plays A and adum tenukis to fill a 1-point ko. white to kill.
+      ]
+      (;W[bc];B[bb]
+      (;W[ca];B[cb]
+      (;W[ab];B[ba]
+      (;W[bi]
+      C[RIGHT black can't push (but no such luck in the actual game)
+      ])
+      )))
+      )
+      INPUT
+      game = @listener.game
+      game.name.should == 'White (W) vs. Black (B)'
+      game.rule.should == 'Japanese'
+      game.board_size.should == 19
+      game.handicap.should == 0
+      game.komi.should == 5.5
+      game.result.should == 'W+R'
+      game.played_on.should == "1999-07-28"
+      game.white_player.should == 'White'
+      game.black_player.should == 'Black'
+      game.program.should == 'Cgoban 1.9.2'
+      game.time_rule.should == '30:00(5x1:00)'
+      
+      root_node = game.root_node
+      root_node.node_type.should == SGF::Model::Constants::NODE_SETUP
+      
+      node2 = root_node.child
+      node2.node_type.should == SGF::Model::Constants::NODE_SETUP
+      node2.trunk?.should be_true
+      node2.comment.should == "guff plays A and adum tenukis to fill a 1-point ko. white to kill."
+      node2.black_moves.should include([3, 0])
+      node2.black_moves.should include([3, 1])
+      node2.white_moves.should include([4, 0])
+      node2.white_moves.should include([4, 1])
+      node2.labels[0].should == SGF::Model::Label.new([1, 3], "A")
+
+      var1_root = node2.children[0]
+      var1_root.trunk?.should be_false
+      var1_root.variation_root?.should be_true
+      var1_root.color.should == SGF::Model::Constants::WHITE
+      var1_root.move.should == [1, 2]
+      
+      var1_node2 = var1_root.child
+      var1_node2.trunk?.should be_false
+      var1_node2.variation_root?.should_not be_true
+      var1_node2.color.should == SGF::Model::Constants::BLACK
+      var1_node2.move.should == [1, 1]
+    end
+  end
+  
+  describe "class methods" do
+    it "parse should take a String and parse it and return the game" do
+      game = SGF::Parser.parse <<-INPUT
+      (;GM[1]FF[3]
+      GN[White (W) vs. Black (B)];
+      )
+      INPUT
+      game.name.should == 'White (W) vs. Black (B)'
+    end
+    
+    it "parse should pass debug parameter to event listener" do
+      event_listener = SGF::Model::EventListener.new(false)
+      mock(SGF::Model::EventListener).new(true) {event_listener}
+      SGF::Parser.parse "(;)", true
+    end
+
+    it "parse_file should take a sgf file and parse it and return the game" do
+      game = SGF::Parser.parse_file File.expand_path(File.dirname(__FILE__) + '/../fixtures/good.sgf')
+      game.name.should == 'White (W) vs. Black (B)'
+    end
+
+    it "parse_file should pass debug parameter to event listener" do
+      event_listener = SGF::Model::EventListener.new(false)
+      mock(SGF::Model::EventListener).new(true) {event_listener}
+      game = SGF::Parser.parse_file(File.expand_path(File.dirname(__FILE__) + '/../fixtures/good.sgf'), true)
+      game.name.should == 'White (W) vs. Black (B)'
+    end
+    
+    it "should parse game with escaped []" do
+      game = SGF::Parser.parse_file(File.expand_path(File.dirname(__FILE__) + '/../fixtures/good1.sgf'))
+    end
+    
+    it "is_binary? should return true for binary file" do
+      pending 'check if file is binary is problematic'
+      SGF::Parser.is_binary?(File.expand_path(File.dirname(__FILE__) + '/../fixtures/test.png')).should be_true
+    end
+  end
+end