SgfParser 2.0.0 → 3.0.0

data/spec/gametree_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+RSpec.describe SGF::Gametree do
+
+  let(:game) { get_first_game_from 'spec/data/ff4_ex.sgf' }
+  let(:root_node) {
+    SGF::Node.new({FF: '4', AP: 'Primiview:3.1',
+                   GM: '1', SZ: '19', GN: 'Gametree 1: properties',
+                   US: 'Arno Hollosi'})
+  }
+  subject { game }
+
+  it 'should throw up if initialized with a non-Node argument' do
+    expect { SGF::Gametree.new('I am a string') }.to raise_error(ArgumentError)
+    expect { SGF::Gametree.new(SGF::Node.new) }.not_to raise_error
+  end
+
+  it 'has game-level information' do
+    expect(subject.name).to eq 'Gametree 1: properties'
+    expect(subject.data_entry).to eq 'Arno Hollosi'
+  end
+
+  it 'should raise errors' do
+    expect { subject.opening }.to raise_error(SGF::NoIdentityError)
+    expect { subject.nonexistent_identity }.to raise_error(SGF::NoIdentityError)
+  end
+
+  it 'has meta information' do
+    expect(subject.inspect).to match(/SGF::Gametree/)
+    expect(subject.inspect).to match(/#{game.object_id}/)
+  end
+
+  context "When talking about nodes" do
+    it "begins on the root node" do
+      expect(subject.current_node).to eq root_node
+    end
+
+    it "should have a nice way to go to children[0]" do
+      subject.next_node
+      expect(subject.current_node).to eq subject.root.children[0]
+    end
+
+    it "should have a way of setting an arbitrary node to the current node" do
+      subject.current_node = subject.root.children[3]
+      expect(subject.current_node.properties.keys).to match_array %w(B C N)
+      expect(subject.current_node.children.size).to eq 6
+    end
+
+  end
+
+  context "blocks" do
+    it "should use preorder traversal for each" do
+      game = get_first_game_from 'spec/data/example1.sgf'
+      array = []
+      game.each { |node| array << node }
+      expect(array[0].c).to eq "root"
+      expect(array[1].c).to eq "a"
+      expect(array[2].c).to eq "b"
+    end
+
+    it "should go through all nodes, even if block returns 'nil' (puts, anyone?)" do
+      game = SGF::Gametree.new root_node
+      game.root.add_children SGF::Node.new(B: "dd")
+      nodes = []
+      game.each { |node| nodes << node; nil }
+      expect(nodes.size).to eq 2
+    end
+  end
+
+  context "Slices" do
+
+    it "should return a node-only gametree if slice is [0..0]" do
+      game = SGF::Gametree.new root_node
+      slice = game.slice(0..0)
+      expect(slice).to be_instance_of SGF::Gametree
+      expect(slice.root).to eq root_node
+    end
+
+    it "should slice through a one-branch list" do
+      node = SGF::Node.new
+      game = SGF::Gametree.new node
+      node.pw = 'Aldric'
+      child1 = SGF::Node.new b: "qq"
+      child2 = SGF::Node.new a: "rn"
+      child3 = SGF::Node.new b: "nr"
+      node.add_children child1
+      child1.add_children child2
+      child2.add_children child3
+      slice = game.slice(1..3)
+      expect(slice).to be_instance_of SGF::Gametree
+      root = slice.root
+      expect(root.b).to eq 'qq'
+      expect(root.parent).to be_nil
+      expect(root.children[0].a).to eq 'rn'
+      expect(root.children[0].children[0].b).to eq 'nr'
+    end
+
+  end
+end

data/spec/node_spec.rb

@@ -1,90 +1,196 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
 
-describe "SGF::Node" do
+RSpec.describe SGF::Node do
 
-  before :each do
-    @node = SGF::Node.new
-  end
+  let(:node) { SGF::Node.new }
+  subject { node }
 
-  it "should be a valid node" do
-    @node.class.should == SGF::Node
-    @node.properties.should == {}
-    @node.parent.should == nil
-    @node.children.should == []
-  end
+  context 'inspect' do
+    subject { node.inspect }
+    it { is_expected.to match(/#{node.object_id}/) }
+    it { is_expected.to match(/SGF::Node/) }
+    it { is_expected.to match(/Has no parent/) }
 
-  it "should store properties" do
-    @node.add_properties "PB" => "Dosaku"
-    @node.properties.should == {"PB" => "Dosaku"}
-  end
+    it "should give you a relatively useful inspect" do
+      node.add_properties({C: "Oh hi", PB: "Dosaku", AE: "[dd][gh]"})
+      is_expected.to match(/3 Properties/)
 
-  it "should link to a parent" do
-    parent = SGF::Node.new
-    @node.parent = parent
-    @node.parent.should == parent
-  end
+      node.add_children SGF::Node.new, SGF::Node.new
+      expect(node.inspect).to match(/2 Children/)
 
-  it "should link to children" do
-    child1 = SGF::Node.new
-    child2 = SGF::Node.new
-    child3 = SGF::Node.new
-    @node.add_children child1, child2, child3
-    @node.children.should == [child1, child2, child3]
-  end
+      node.parent = SGF::Node.new
+      expect(node.inspect).to match(/Has a parent/)
+    end
 
-  it "should link to children, who should get new parents" do
-    child1 = SGF::Node.new
-    child2 = SGF::Node.new
-    child3 = SGF::Node.new
-    @node.add_children child1, child2, child3
-    @node.children.each { |child| child.parent.should == @node }
   end
 
-  it "should allow concatenation of properties" do
-    @node.add_properties "TC" => "Hello,"
-    @node.add_properties "TC" => " world!"
-    @node.properties["TC"].should == "Hello, world!"
+  it "should properly show a string version of the node" do
+    subject.add_properties({"C" => "Oh hi]", "PB" => "Dosaku"})
+    expect(subject.to_s).to eq ";C[Oh hi\\]]\nPB[Dosaku]"
   end
 
-  it "should give you the properties based on method given" do
-    @node.add_properties "PW" => "The Tick"
-    @node.add_properties "PB" => "Batmanuel"
-    @node.pw.should == "The Tick"
-    @node.pb.should == "Batmanuel"
+  it "should properly show a string version of the node if identities are symbols" do
+    subject.add_properties({C: "Oh hi]", PB: "Dosaku"})
+    expect(subject.to_s).to eq ";C[Oh hi\\]]\nPB[Dosaku]"
   end
 
-  it "should allow you to change a property completely" do
-    @node.add_properties "RE" => "This is made up"
-    @node.properties["RE"] = "This is also made up"
-    @node.re.should == "This is also made up"
-    @node.re = "And that too"
-    @node.re.should == "And that too"
+  context "Heredity" do
+
+    let(:parent) { SGF::Node.new }
+    let(:child1) { SGF::Node.new }
+    let(:child3) { SGF::Node.new }
+    let(:child2) { SGF::Node.new }
+
+    it "should link to a parent" do
+      subject.parent = parent
+      expect(subject.parent).to eq parent
+    end
+
+    it "should link to children" do
+      node.add_children child1, child2, child3
+      expect(node.children).to eq [child1, child2, child3]
+    end
+
+    it "should link to children, who should get new parents" do
+      node.add_children child1, child2, child3
+      node.children.each { |child| expect(child.parent).to eq node }
+    end
+
+    it "should not be the child of many nodes" do
+      parent2 = SGF::Node.new
+      parent.add_children node
+      parent2.add_children node
+      expect(node.parent).to eq(parent2)
+      expect(parent2.children).to include(node)
+      expect(parent.children).to_not include(node)
+    end
+
+    it "should become a child of its new parent" do
+      node.parent = parent
+      expect(parent.children).to include node
+    end
+
   end
 
-  it "should implement [] as a shortcut to read properties" do
-    @node.add_properties "PB" => "Dosaku"
-    @node["PB"].should == "Dosaku"
-    @node[:PB].should == "Dosaku"
+  context "Properties" do
+
+    it "should store properties" do
+      node.add_properties PB: "Dosaku"
+      expect(node.properties).to eq({"PB" => "Dosaku"})
+    end
+
+    it "should allow concatenation of properties" do
+      node.add_properties "TC" => "Hello,"
+      node.add_properties "TC" => " world!"
+      expect(node.properties["TC"]).to eq "Hello, world!"
+    end
+
+    it "should give you the properties based on method given" do
+      node.add_properties "PW" => "The Tick"
+      node.add_properties "PB" => "Batmanuel"
+      expect(node.pw).to eq "The Tick"
+      expect(node.pb).to eq "Batmanuel"
+    end
+
+    it "should allow you to change a property completely" do
+      node.add_properties "RE" => "This is made up"
+      node.properties["RE"] = "This is also made up"
+      expect(node.re).to eq "This is also made up"
+      node.re = "And that too"
+      expect(node.re).to eq "And that too"
+      node[:RE] = 'kokolegorille'
+      expect(node[:RE]).to eq 'kokolegorille'
+    end
+
+    it "should implement [] as a shortcut to read properties" do
+      node.add_properties "PB" => "Dosaku"
+      expect(node["PB"]).to eq "Dosaku"
+      expect(node[:PB]).to eq "Dosaku"
+    end
+
   end
 
-  it "should give you a relatively useful inspect" do
-    @node.inspect.should match /#{@node.object_id}/
-    @node.inspect.should match /SGF::Node/
+  context "Node depth" do
+
+    it "should get a node depth number one more by the parent when attached to a parent" do
+      child = SGF::Node.new
+      node.add_children child
+      expect(node.depth).to eq 0
+      expect(child.depth).to eq 1
+    end
+
+    it "should properly set depth if a parent is passed to initializer" do
+      node2 = SGF::Node.new parent: node
+      expect(node2.parent).to eq node
+      expect(node2.depth).to eq 1
+    end
+
+    it "should properly update depth when parentage changes" do
+      link1 = SGF::Node.new
+      link2 = SGF::Node.new
+      link2.parent = link1
+      link1.parent = node
+      expect(node.parent).to be_nil
+      expect(link1.parent).to eq node
+      expect(link2.parent).to eq link1
+      expect(node.depth).to eq 0
+      expect(link1.depth).to eq 1
+      expect(link2.depth).to eq 2
+    end
+
+    it "should properly update depth if parent is set to nil / parent is removed" do
+      parent = SGF::Node.new
+      child = SGF::Node.new
+
+      node.add_children child
+      node.parent = parent
+      expect(node.depth).to eq 1
+      expect(child.depth).to eq 2
+
+      node.parent = nil
+      expect(node.depth).to eq 0
+      expect(child.depth).to eq 1
+
+      node.parent = parent
+      expect(node.depth).to eq 1
+      expect(child.depth).to eq 2
+
+      node.remove_parent
+      expect(node.depth).to eq 0
+      expect(child.depth).to eq 1
+    end
+
+    it "should properly update depth when childhood changes" do
+      link1 = SGF::Node.new
+      link2 = SGF::Node.new
+      link3 = SGF::Node.new
+      link1.add_children link2
+      link2.add_children link3
+      node.add_children link1
+      node.add_children link3
+      expect(node.depth).to eq 0
+      expect(link1.depth).to eq 1
+      expect(link2.depth).to eq 2
+      expect(link3.depth).to eq 1
+    end
+  end
 
-    @node.add_properties({"C" => "Oh hi", "PB" => "Dosaku", "AE" => "[dd][gh]"})
-    @node.inspect.should match /3 Properties/
+  context "self-consistency" do
+    it "should only track  changes from its current parent" do
+      link1 = SGF::Node.new
+      link2 = SGF::Node.new
 
-    @node.add_children SGF::Node.new, SGF::Node.new
-    @node.inspect.should match /2 Children/
+      link3 = SGF::Node.new
+      link1.add_children link2
+      node.parent = link2
+      expect(node.depth).to eq 2
 
-    @node.inspect.should match /Has no parent/
-    @node.parent = SGF::Node.new
-    @node.inspect.should match /Has a parent/
-  end
+      link1.depth = 2
+      expect(node.depth).to eq 4
 
-  it "should properly show a string version of the node" do
-    @node.add_properties({"C" => "Oh hi]", "PB" => "Dosaku"})
-    @node.to_str.should == ";C[Oh hi\\]]\nPB[Dosaku]"
+      node.parent = link3
+      link1.depth = 6
+      expect(node.depth).to eq 1
+    end
   end
-
-end
+end

data/spec/parser_spec.rb

@@ -1,117 +1,119 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
 
-describe "SGF::Parser" do
+RSpec.describe SGF::Parser do
 
-  it "should give an error if the first two character are not (;" do
-    parser = sgf_parser
-    expect { parser.parse ';)' }.to raise_error SGF::MalformedDataError
-  end
+  let(:parser) { SGF::Parser.new }
+
+  describe "when given invalid SGF files" do
+    it "should give an error if the first two character are not (;" do
+      expect { parser.parse ';)' }.to raise_error SGF::MalformedDataError
+    end
+
+    it "should not give an error if it is told to sit down and shut up" do
+      expect { parser.parse(';)', false) }.to_not raise_error
+    end
+
+    it "should properly parse a file that has many AB/AW/AE values in a single node" do
+      invalid_sgf = "(;AB[dd]AB[aa])"
+      collection = parser.parse invalid_sgf
+
+      node = SGF::Node.new AB: %w[dd aa]
+      expected = SGF::Collection.new
+      expected.root.add_children node
 
-  it "should not give an error if it is told to sit down and shut up" do
-    parser = sgf_parser
-    expect { parser.parse ';)', false}.to_not raise_error
+      expect(collection).to eq expected
+      expect(collection.errors).to include "Multiple AB identities are present in a single node. A property should only exist once per node."
+    end
   end
 
   it "should parse a simple node" do
-    parser = sgf_parser
-    tree = parser.parse ";PW[5]", false
-    tree.root.children[0].pw.should == "5"
+    collection = parser.parse ";PW[Dosaku]", false
+    expect(collection.root.children[0].pw).to eq "Dosaku"
   end
 
   it "should parse a node with two properties" do
-    parser = sgf_parser
-    tree = parser.parse ";PB[Aldric]PW[Bob]", false
-    tree.root.children[0].pb.should == "Aldric"
-    tree.root.children[0].pw.should == "Bob"
+    collection = parser.parse ";PB[Aldric]PW[Bob]", false
+    expect(collection.root.children[0].pb).to eq "Aldric"
+    expect(collection.root.children[0].pw).to eq "Bob"
+  end
+
+  it "should apparently ignore line breaks in the middle of a property name -- is this right?" do
+    collection = parser.parse ";P\nB[Aldric]P\n\n\nW[Bob]", false
+    expect(collection.root.children[0].pb).to eq "Aldric"
+    expect(collection.root.children[0].pw).to eq "Bob"
   end
 
   it "should parse two nodes with one property each" do
-    parser = sgf_parser
-    tree = parser.parse ";PB[Aldric];PW[Bob]", false
-    node = tree.root.children[0]
-    node.pb.should == "Aldric"
-    node.children[0].pw.should == "Bob"
+    collection = parser.parse ";PB[Aldric];PW[Bob]", false
+    node = collection.root.children[0]
+    expect(node.pb).to eq "Aldric"
+    expect(node.children[0].pw).to eq "Bob"
   end
 
   it "should parse a tree with a single branch" do
-    parser = sgf_parser
-    tree = parser.parse "(;FF[4]PW[Aldric]PB[Bob];B[qq])"
-    node = tree.root.children[0]
-    node.pb.should == "Bob"
-    node.pw.should == "Aldric"
-    node.children[0].b.should == "qq"
+    collection = parser.parse "(;FF[4]PW[Aldric]PB[Bob];B[qq])"
+    node = collection.root.children[0]
+    expect(node.pb).to eq "Bob"
+    expect(node.pw).to eq "Aldric"
+    expect(node.children[0].b).to eq "qq"
   end
 
   it "should parse a tree with two branches" do
-    parser = sgf_parser
-    tree = parser.parse "(;FF[4](;C[main])(;C[branch]))"
-    node = tree.root.children[0]
-    node.ff.should == "4"
-    node.children.size.should == 2
-    node.children[0].c.should == "main"
-    node.children[1].c.should == "branch"
+    collection = parser.parse "(;FF[4](;C[main])(;C[branch]))"
+    node = collection.root.children[0]
+    expect(node.ff).to eq "4"
+    expect(node.children.size).to eq 2
+    expect( node.children[0].c).to eq "main"
+    expect(node.children[1].c).to eq "branch"
   end
 
-  it "should parse a comment with a ] inside" do
-    parser = sgf_parser
-    tree = parser.parse "(;C[Oh hi\\] there])"
-    tree.root.children[0].c.should == "Oh hi] there"
+  it "should parse a comment with a \\] inside" do
+    collection = parser.parse "(;C[Oh hi\\] there])"
+    expect(collection.root.children[0].c).to eq "Oh hi] there"
   end
 
   it "should parse a multi-property identity well" do
-    parser = sgf_parser
-    tree = parser.parse "(;FF[4];AW[bd][cc][qr])"
-    tree.root.children[0].children[0].aw.should == ["bd", "cc", "qr"]
+    collection = parser.parse "(;FF[4];AW[bd][cc][qr])"
+    expect(collection.root.children[0].children[0].aw).to eq %w(bd cc qr)
   end
 
   it "should parse multiple trees" do
-    parser = sgf_parser
-    tree = parser.parse "(;FF[4]PW[Aldric];AW[dd][cc])(;FF[4]PW[Hi];PB[ad])"
-    tree.root.children.size.should == 2
-    tree.root.children[0].children[0].aw.should == ["dd", "cc"]
-    tree.root.children[1].children[0].pb.should == "ad"
+    collection = parser.parse "(;FF[4]PW[Aldric];AW[dd][cc])(;FF[4]PW[Hi];PB[ad])"
+    expect(collection.root.children.size).to eq 2
+    expect(collection.root.children[0].children[0].aw).to eq %w(dd cc)
+    expect(collection.root.children[1].children[0].pb).to eq "ad"
   end
 
   it "should not put (; into the identity when separated by line breaks" do
-    parser = sgf_parser
-    tree = parser.parse "(;FF[4]\n\n(;B[dd])(;B[da]))"
-    game = tree.root.children[0]
-    game.children.size.should == 2
-    game.children[0].b.should == "dd"
-    game.children[1].b.should == "da"
+    collection = parser.parse "(;FF[4]\n\n(;B[dd])(;B[da]))"
+    game = collection.root.children[0]
+    expect(game.children.size).to eq 2
+    expect(game.children[0].b).to eq "dd"
+    expect( game.children[1].b).to eq "da"
   end
 
   it "should parse the simplified sample SGF" do
-    parser = sgf_parser
-    tree = parser.parse SIMPLIFIED_SAMPLE_SGF
-    root = tree.root
-    root.children.size.should == 2
+    collection = parser.parse SIMPLIFIED_SAMPLE_SGF
+    root = collection.root
+    expect(root.children.size).to eq 2
     node = root.children[0].children[0]
-    node.ar.should == ["aa:sc", "sa:ac", "aa:sa", "aa:ac", "cd:cj", "gd:md", "fh:ij", "kj:nh"]
+    expect(node.ar).to eq %w(aa:sc sa:ac aa:sa aa:ac cd:cj gd:md fh:ij kj:nh)
   end
 
   it "should parse a file if given a file handler as input" do
-    parser = sgf_parser
     file = File.open 'spec/data/simple.sgf'
-    tree = parser.parse file
-    game = tree.games.first
-    game.white_player.should == "redrose"
-    game.black_player.should == "tartrate"
+    collection = parser.parse file
+    game = collection.gametrees.first
+    expect(game.white_player).to eq "redrose"
+    expect(game.black_player).to eq "tartrate"
   end
 
-  it "should parse a file if given a local path as input"  do
-    parser = sgf_parser
+  it "should parse a file if given a local path as input" do
     local_path = 'spec/data/simple.sgf'
-    tree = parser.parse local_path
-    game = tree.games.first
-    game.white_player.should == "redrose"
-    game.black_player.should == "tartrate"
-  end
-
-  private
-
-  def sgf_parser
-    SGF::Parser.new
+    collection = parser.parse local_path
+    game = collection.gametrees.first
+    expect(game.white_player).to eq "redrose"
+    expect(game.black_player).to eq "tartrate"
   end
 
 end