SgfParser 1.0.0 → 2.0.0

data/lib/sgf/tree.rb

@@ -1,22 +1,20 @@
 module SGF
 
+  #Tree holds most of the logic, for now. It has all the nodes, can iterate over them, and can even save to a file!
+  #Somehow this feels like it should be split into another class or two...
   class Tree
     include Enumerable
 
-    attr_accessor :root
+    attr_accessor :root, :current_node, :errors
 
-    def initialize sgf
+    def initialize
       @root = Node.new
-      @sgf = sgf
+      @current_node = @root
+      @errors = []
     end
 
-    def each order=:preorder, &block
-      # I know, I know. SGF is only preorder. Well, it's implemented, ain't it?
-      # Stop complaining.
-      case order
-        when :preorder
-          preorder @root, &block
-      end
+    def each
+      games.each { |game| game.each { |node| yield node } }
     end
 
     # Compares a tree to another tree, node by node.
@@ -29,54 +27,43 @@ module SGF
       one == two
     end
 
-    # Saves the tree as an SGF file. raises an error if a filename is not given.
-    # tree.save :filename => file_name
-    def save args={}
-      raise ArgumentError, "No file name provided" if args[:filename].nil?
-      @savable_sgf = "("
-      @root.children.each { |child| write_node child }
-      @savable_sgf << ")"
+    #Returns an array of the Game objects in this tree.
+    def games
+      populate_game_array
+    end
 
-      File.open(args[:filename], 'w') { |f| f << @savable_sgf }
+    def to_s
+      out = "#<SGF::Tree:#{self.object_id}, "
+      out << "#{games.count} Games, "
+      out << "#{node_count} Nodes"
+      out << ">"
     end
 
-    private
+    alias :inspect :to_s
 
-    # Adds a stringified node to the variable @savable_sgf.
-    def write_node node=@root
-      @savable_sgf << ";"
-      unless node.properties.empty?
-        properties = ""
-        node.properties.each do |identity, property|
-          new_property = property[1...-1]
-          new_property.gsub!("]", "\\]") if identity == "C"
-          properties += "#{identity.to_s}[#{new_property}]"
-        end
-        @savable_sgf << properties
-      end
+    def to_str
+      SGF::Writer.new.stringify_tree_from @root
+    end
 
-      case node.children.size
-        when 0
-          @savable_sgf << ")"
-        when 1
-          write_node node.children[0]
-        else
-          node.each_child do |child|
-            @savable_sgf << "("
-            write_node child
-          end
-      end
+    # Saves the Tree as an SGF file. Takes a filename as argument.
+    def save filename
+      SGF::Writer.new.save(@root, filename)
     end
 
-    # Traverse the tree in preorder fashion, starting with the @root node if
-    # no node is given, and activating the passed block on each.
-    def preorder node=@root, &block
-      # stop processing if the block returns false
-      if yield node then
-        node.each_child do |child|
-          preorder(child, &block)
-        end
+    private
+
+    def node_count
+      count = 0
+      games.each { |game| count += game.node_count }
+      count
+    end
+
+    def populate_game_array
+      games = []
+      @root.children.each do |first_node_of_gametree|
+        games << Game.new(first_node_of_gametree)
       end
+      games
     end
 
     def method_missing method_name, *args
@@ -85,7 +72,6 @@ module SGF
       output
     end
 
-  end
-
-end
+  end # Tree
+end # SGF
 

data/lib/sgf/version.rb

@@ -0,0 +1,3 @@
+module SGF
+  VERSION = "2.0.0"
+end

data/lib/sgf/writer.rb

@@ -0,0 +1,54 @@
+module SGF
+  class Writer
+
+  def stringify_tree_from root_node
+    @indentation = 0
+    @sgf = ""
+    write_new_branch_from root_node
+  end
+
+    # Takes a node and a filename as arguments
+    def save(root_node, filename)
+      stringify_tree_from root_node
+
+      File.open(filename, 'w') { |f| f << @sgf }
+    end
+
+    private
+
+    def write_tree_from node
+      @sgf << "\n" << node.to_str(@indentation)
+      decide_what_comes_after node
+    end
+
+    def decide_what_comes_after node
+      if node.children.size == 1
+      then write_tree_from node.children[0]
+      else write_new_branch_from node
+      end
+    end
+
+    def write_new_branch_from node
+      node.each_child do |child_node|
+        open_branch
+        write_tree_from child_node
+        close_branch
+      end
+    end
+
+    def open_branch
+      @sgf << "\n" << whitespace << "("
+      @indentation += 2
+    end
+
+    def close_branch
+      @indentation -= 2
+      @indentation = (@indentation < 0) ? 0 : @indentation
+      @sgf << "\n" << whitespace << ")"
+    end
+
+    def whitespace
+      " " * @indentation
+    end
+  end
+end

data/spec/data/example1.sgf

@@ -0,0 +1,10 @@
+(;FF[4]C[root]
+    (;C[a];C[b]
+        (;C[c])
+        (;C[d];C[e])
+    )
+    (;C[f]
+        (;C[g];C[h];C[i])
+        (;C[j])
+    )
+)

data/spec/game_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "SGF::Game" do
+
+  it "should hold the first node of the game" do
+    game = get_first_game_from 'spec/data/ff4_ex.sgf'
+    game.current_node["FF"].should == "4"
+  end
+
+  it "should throw up if initialized with a non-Node argument" do
+    expect { SGF::Game.new("I am a string") }.to raise_error(ArgumentError)
+    expect { SGF::Game.new(SGF::Node.new) }.to_not raise_error(ArgumentError)
+  end
+
+  it "should have the expected game-level information" do
+    game = get_first_game_from 'spec/data/ff4_ex.sgf'
+    game.name.should == "Gametree 1: properties"
+    game.data_entry.should == "Arno Hollosi"
+    expect { game.opening }.to raise_error(SGF::NoIdentityError)
+    expect { game.nonexistent_identity }.to raise_error(NoMethodError)
+  end
+
+  it "should give you a minimum of useful information on inspect" do
+    game = get_first_game_from 'spec/data/simple.sgf'
+    inspect = game.inspect
+    inspect.should match /SGF::Game/
+    inspect.should match /#{game.object_id}/
+  end
+
+  context "When talking about nodes" do
+
+    it "should have 'root' as the default current node" do
+      game = get_first_game_from 'spec/data/ff4_ex.sgf'
+      game.current_node.should == game.root
+    end
+
+    it "should have a nice way to go to children[0]" do
+      game = get_first_game_from 'spec/data/ff4_ex.sgf'
+      game.next_node
+      game.current_node.should == game.root.children[0]
+    end
+
+    it "should have a way of setting an arbitrary node to the current node" do
+      game = get_first_game_from 'spec/data/ff4_ex.sgf'
+      game.current_node = game.root.children[3]
+      game.current_node.properties.keys.sort.should == ["B", "C", "N"]
+      game.current_node.children.size.should == 6
+    end
+
+  end
+
+  it "should use preorder traversal for each" do
+    game = get_first_game_from 'spec/data/example1.sgf'
+    array = []
+    game.each { |node| array << node }
+    array[0].c.should == "root"
+    array[1].c.should == "a"
+    array[2].c.should == "b"
+  end
+
+  it "should go through all nodes, even if block returns 'nil' (puts, anyone?)" do
+    root = SGF::Node.new :properties => {"FF" => "4", "PB" => "Me", "PW" => "You"}
+    game = SGF::Game.new root
+    root.add_children SGF::Node.new(:properties => {"B" => "dd"})
+    nodes = []
+    game.each { |node| nodes << node; nil }
+    nodes.size.should == 2
+  end
+
+end

data/spec/node_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "SgfParser::Node" do
+describe "SGF::Node" do
 
   before :each do
     @node = SGF::Node.new
@@ -40,7 +40,7 @@ describe "SgfParser::Node" do
     @node.children.each { |child| child.parent.should == @node }
   end
 
-  it "should allow properties to be added to" do
+  it "should allow concatenation of properties" do
     @node.add_properties "TC" => "Hello,"
     @node.add_properties "TC" => " world!"
     @node.properties["TC"].should == "Hello, world!"
@@ -61,4 +61,30 @@ describe "SgfParser::Node" do
     @node.re.should == "And that too"
   end
 
+  it "should implement [] as a shortcut to read properties" do
+    @node.add_properties "PB" => "Dosaku"
+    @node["PB"].should == "Dosaku"
+    @node[:PB].should == "Dosaku"
+  end
+
+  it "should give you a relatively useful inspect" do
+    @node.inspect.should match /#{@node.object_id}/
+    @node.inspect.should match /SGF::Node/
+
+    @node.add_properties({"C" => "Oh hi", "PB" => "Dosaku", "AE" => "[dd][gh]"})
+    @node.inspect.should match /3 Properties/
+
+    @node.add_children SGF::Node.new, SGF::Node.new
+    @node.inspect.should match /2 Children/
+
+    @node.inspect.should match /Has no parent/
+    @node.parent = SGF::Node.new
+    @node.inspect.should match /Has a parent/
+  end
+
+  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]"
+  end
+
 end

data/spec/parser_spec.rb

@@ -1,20 +1,117 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "SgfParser::Tree.parse" do
+describe "SGF::Parser" do
 
-  it "should have FF in the first node" do
-    tree = SGF::Parser.new('spec/data/ff4_ex.sgf').parse
-    tree.root.children[0].properties.keys.should include("FF")
+  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
 
-  it "should give an error if FF is missing from the first node" do
-    pending "To be coded later"
+  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
   end
 
-  it "should parse properly the AW property" do
-    sgf = "dd][de][ef]"
-    parser = SGF::Parser.new sgf
-    parser.get_property.should == "[dd][de][ef]"
+  it "should parse a simple node" do
+    parser = sgf_parser
+    tree = parser.parse ";PW[5]", false
+    tree.root.children[0].pw.should == "5"
+  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"
+  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"
+  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"
+  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"
+  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"
+  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"]
+  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"
+  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"
+  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
+    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"]
+  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"
+  end
+
+  it "should parse a file if given a local path as input"  do
+    parser = sgf_parser
+    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
   end
 
 end

data/spec/spec_helper.rb

@@ -1,6 +1,30 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
 require 'sgf'
+require 'fileutils'
 require 'rspec'
 require 'rspec/autorun'
 
+ONE_LINE_SIMPLE_SAMPLE_SGF= "(;FF[4]AP[Primiview:3.1]GM[1]SZ[19](;DD[kq:os][dq:hs]AR[aa:sc][sa:ac][aa:sa][aa:ac][cd:cj][gd:md][fh:ij][kj:nh]LN[pj:pd][nf:ff][ih:fj][kh:nj]C[Arrows, lines and dimmed points.])(;B[qd]N[Style & text type]))(;FF[4]AP[Primiview:3.1]GM[1]SZ[19])"
+
+SIMPLIFIED_SAMPLE_SGF= <<EOF
+(;FF[4]AP[Primiview:3.1]GM[1]SZ[19]
+  (;DD[kq:os][dq:hs]
+    AR[aa:sc][sa:ac][aa:sa][aa:ac][cd:cj]
+    [gd:md][fh:ij][kj:nh]
+    LN[pj:pd][nf:ff][ih:fj][kh:nj]
+    C[Arrows, lines and dimmed points.])
+  (;B[qd]N[Style & text type])
+)
+(;FF[4]AP[Primiview:3.1]GM[1]SZ[19])
+EOF
+
+def get_first_game_from file
+  tree = get_tree_from file
+  tree.games.first
+end
+
+def get_tree_from file
+  parser = SGF::Parser.new
+  parser.parse File.read(file)
+end