SgfParser 1.0.0 → 2.0.0

data/lib/sgf/node.rb

@@ -1,51 +1,98 @@
 module SGF
 
+  #Your basic node. It holds information about itself, its parent, and its children.
   class Node
 
     attr_accessor :parent, :children, :properties
 
     # Creates a new node. Arguments which can be passed in are:
     # :parent => parent_node (nil by default)
-    # :children => [list, of, children] (empty array by default)
-    # :properties => {hash_of => properties} (empty hash by default)
+    # :children => [list, of, children] (empty array if nothing is passed)
+    # :properties => {hash_of => properties} (empty hash if nothing is passed)
     def initialize args={}
       @parent = args[:parent]
       @children = []
       add_children args[:children] if args[:children]
       @properties = Hash.new
-      @properties.merge! args[:properties] if args[:properties]
+      add_properties args[:properties] if args[:properties]
     end
 
+    #Takes an arbitrary number of child nodes, adds them to the list of children, and make this node their parent.
     def add_children *nodes
       nodes.flatten!
       raise "Non-node child given!" if nodes.any? { |node| node.class != Node }
-      nodes.each { |node| node.parent = self }
-      @children.concat nodes
+      nodes.each do |node|
+        node.parent = self
+        @children << node
+      end
     end
 
+    #Takes a hash {identity => property} and adds those to the current node.
+    #If a property already exists, it will append to it.
     def add_properties hash
-      hash.each do |key, value|
-        @properties[key] ||= ""
-        @properties[key].concat value
+      hash.each do |identity, property|
+        @properties[identity] ||= property.class.new
+        @properties[identity].concat property
       end
+      update_human_readable_methods
     end
 
+    #Iterate through each child. Yields a child node, if one exists.
     def each_child
       @children.each { |child| yield child }
     end
 
+    #Compare to another node.
     def == other_node
       @properties == other_node.properties
     end
 
-    def comments
-      @properties["C"]
+    #Syntactic sugar for node.properties["XX"]
+    def [] identity
+      identity = identity.to_s
+      @properties[identity]
+    end
+
+    def to_s
+      out = "#<#{self.class}:#{self.object_id}, "
+      out << (@parent ? "Has a parent, " : "Has no parent, ")
+      out << "#{@children.size} Children, "
+      out << "#{@properties.keys.size} Properties"
+      out << ">"
     end
 
-    alias :comment :comments
+    alias :inspect :to_s
+
+    def to_str(indent = 0)
+      properties = []
+      @properties.each do |identity, property|
+        properties << stringify_identity_and_property(identity, property)
+      end
+      whitespace = leading_whitespace(indent)
+      "#{whitespace};#{properties.join("\n#{whitespace}")}"
+    end
+
+    def stringify_identity_and_property(identity, property)
+      new_property = property.instance_of?(Array) ? property.join("][") : property
+      new_property = new_property.gsub("]", "\\]") if identity == "C"
+      "#{identity.to_s}[#{new_property}]"
+    end
 
     private
 
+    def update_human_readable_methods
+      SGF::Node::PROPERTIES.each do |human_readable_method, sgf_identity|
+        next if defined? human_readable_method.to_sym
+        define_method(human_readable_method.to_sym) do
+          @properties[sgf_identity] ? @properties[sgf_identity] : raise(SGF::NoIdentityError)
+        end
+      end
+    end
+
+    def leading_whitespace(indent)
+      "#{" " * indent}"
+    end
+
     def method_missing method_name, *args
       property = method_name.to_s.upcase
       if property[/(.*?)=$/]

data/lib/sgf/parser.rb

@@ -1,120 +1,167 @@
 require 'stringio'
 
 module SGF
+
+  #The parser returns a SGF::Tree representation of the SGF file
+  #parser = SGF::Parser.new
+  #tree = parser.parse sgf_in_string_form
   class Parser
 
-    def initialize sgf
-      @sgf = stringified(sgf)
-      @tree = Tree.new sgf
+    NEW_NODE = ";"
+    BRANCHING = ["(", ")"]
+    PROPERTY = ["[", "]"]
+    NODE_DELIMITERS = [NEW_NODE].concat BRANCHING
+    LIST_IDENTITIES = ["AW", "AB", "AE", "AR", "CR", "DD",
+                       "LB", "LN", "MA", "SL", "SQ", "TR", "VW",
+                       "TB", "TW"]
+
+    # This takes as argument an SGF and returns an SGF::Tree object
+    # It accepts a local path (String), a stringified SGF (String),
+    # or a file handler (File).
+    # The second argument is optional, in case you don't want this to raise errors.
+    # You probably shouldn't use it, but who's gonna stop you?
+    def parse sgf, strict_parsing = true
+      @strict_parsing = strict_parsing
+      @stream = streamably_stringify sgf
+      @tree = Tree.new
       @root = @tree.root
+      @current_node = @root
+      @branches = []
+      until @stream.eof?
+        case next_character
+          when "(" then open_branch
+          when ";" then
+            create_new_node
+            parse_node_data
+            add_properties_to_current_node
+          when ")" then close_branch
+          else next
+        end
+      end
+      @tree
     end
 
-    def stringified sgf
-      File.exist?(sgf) ? File.read(sgf) : sgf
+    private
+
+    def streamably_stringify sgf
+      sgf = sgf.read if sgf.instance_of?(File)
+      sgf = File.read(sgf) if File.exist?(sgf)
+
+      check_for_errors_before_parsing sgf if @strict_parsing
+      StringIO.new clean(sgf), 'r'
     end
 
-    def parse
-      while char = next_character
-        case char
-          when '(' then store_branch
-          when ')' then fetch_branch
-          when ';' then store_node_and_create_new_node
-          when '[' then get_and_store_property
-          else store_character(char)
-        end
+    def check_for_errors_before_parsing string
+      msg = "The first two non-whitespace characters of the string should be (;"
+      unless string[/\A\s*\(\s*;/]
+        msg << " but they were #{string[0..1]} instead."
+        raise(SGF::MalformedDataError, msg)
       end
-      @tree
     end
 
-    def next_character
-      character_available? && @stream.sysread(1)
+    def clean sgf
+      sgf.gsub! "\\\\n\\\\r", ''
+      sgf.gsub! "\\\\r\\\\n", ''
+      sgf.gsub! "\\\\r", ''
+      sgf.gsub! "\\\\n", ''
+      sgf
     end
 
-    def character_available?
-      @stream ||= StringIO.new clean_string, 'r'
-      !@stream.eof?
+    def open_branch
+      @branches.unshift @current_node
     end
 
-    def clean_string
-      @sgf.gsub! "\\\\n\\\\r", ""
-      @sgf.gsub! "\\\\r\\\\n", ""
-      @sgf.gsub! "\\\\r", ""
-      @sgf.gsub! "\\\\n", ""
-      @sgf
-    end    
+    def close_branch
+      @current_node = @branches.shift
+    end
 
-    def store_branch
-      @branches ||= []
-      @branches.unshift @current_node
+    def create_new_node
+      node = Node.new
+      @current_node.add_children node
+      @current_node = node
     end
 
-    def current_node
-      @current_node ||= @root
-    end    
+    def parse_node_data
+      @node_properties = {}
+      while still_inside_node?
+        parse_identity
+        parse_property
+        @node_properties[@identity] = @property
+      end
+    end
 
-    def fetch_branch
-      @current_node = @branches.shift
-      clear_temporary_data
+    def add_properties_to_current_node
+      @current_node.add_properties @node_properties
     end
 
-    def store_node_and_create_new_node
-      parent = current_node
-      @current_node = Node.new :parent => parent
-      parent.add_properties content
-      parent.add_children @current_node
-      clear_temporary_data
+    def still_inside_node?
+      inside_a_node = false
+      while char = next_character
+        next if char[/\s/]
+        inside_a_node = !NODE_DELIMITERS.include?(char)
+        break
+      end
+      @stream.pos -= 1 if char
+      inside_a_node
     end
 
-    def get_and_store_property
-      @content[@identity] ||= ""
-      @content[@identity] << get_property
+    def parse_identity
       @identity = ""
+      while char = next_character and char != "["
+        @identity << char unless char == "\n"
+      end
     end
 
-    def get_property
-      buffer = ""
-      while char = next_character
-        case char
-          when "]" then break unless multiple_properties?
-          when "\\" then
-            char << next_character
-            char = "]" if char == "\\]"
-        end
+    def parse_property
+      @property = ""
+      case @identity.upcase
+        when "C" then parse_comment
+        when *LIST_IDENTITIES then parse_multi_property
+        else parse_generic_property
+      end
+    end
 
-        buffer << char
+    def parse_comment
+      while char = next_character and still_inside_comment? char
+        @property << char
       end
-      "[#{buffer}]"
+      @property.gsub! "\\]", "]"
     end
 
-    def multiple_properties?
-      multiple_properties = false
-      if char = next_character
-        char = next_character if char == "\n"
-        if char == "["
-          multiple_properties = true
-        end
-        @stream.pos -= 1
-        multiple_properties
+    def parse_multi_property
+      while char = next_character and still_inside_multi_property? char
+        @property << char
       end
+      @property = @property.gsub("][", ",").split(",")
     end
 
-    def store_character(char)
-      @identity << char unless char == "\n"
+    def parse_generic_property
+      while char = next_character and char != "]"
+        @property << char
+      end
     end
 
-    def clear_temporary_data
-      @content.clear
-      @identity = ""
+    def still_inside_comment? char
+      char != "]" || (char == "]" && @property[-1..-1] == "\\")
     end
 
-    def content
-      @content ||= {}
+    def still_inside_multi_property? char
+      return true if char != "]"
+      inside_multi_property = false
+      while char = next_character
+        next if char[/\s/]
+        inside_multi_property = char == "["
+        break
+      end
+      @stream.pos -= 1 if char
+      inside_multi_property
     end
 
-    def identity
-      @identity ||= ""      
+    def next_character
+      !@stream.eof? && @stream.sysread(1)
     end
 
   end
+
 end
 

data/lib/sgf/properties.rb

@@ -1,97 +1,90 @@
-# A parser for SGF Files. Main usage: SGF::Tree.new :filename => file_name
-module SgfParser
+module SGF
 
 #  http://www.red-bean.com/sgf/proplist.html
 
-# Here we define SGF::Properties, so we can figure out what each property
-# is and does.
+  class Game
 
-  property_string = %Q{AB   Add Black       setup            list of stone
-AE   Add Empty       setup            list of point
-AN   Annotation      game-info        simpletext
-AP  Application     root	      composed simpletext ':' simpletext
-AR  Arrow           -                list of composed point ':' point
-AS  Who adds stones - (LOA)          simpletext
-AW   Add White       setup            list of stone
-B    Black           move             move
-BL   Black time left move             real
-BM   Bad move        move             double
-BR   Black rank      game-info        simpletext
-BT   Black team      game-info        simpletext
-C    Comment         -                text
-CA  Charset         root	      simpletext
-CP   Copyright       game-info        simpletext
-CR   Circle          -                list of point
-DD  Dim points      - (inherit)      elist of point
-DM   Even position   -                double
-DO   Doubtful        move             none
-DT  Date            game-info        simpletext
-EV   Event           game-info        simpletext
-FF   Fileformat      root	      number (range: 1-4)
-FG  Figure          -                none | composed number ":" simpletext
-GB   Good for Black  -                double
-GC   Game comment    game-info        text
-GM   Game            root	      number (range: 1-5,7-16)
-GN   Game name       game-info        simpletext
-GW   Good for White  -                double
-HA   Handicap        game-info (Go)   number
-HO   Hotspot         -                double
-IP  Initial pos.    game-info (LOA)  simpletext
-IT   Interesting     move             none
-IY  Invert Y-axis   game-info (LOA)  simpletext
-KM   Komi            game-info (Go)   real
-KO   Ko              move             none
-LB  Label           -                list of composed point ':' simpletext
-LN  Line            -                list of composed point ':' point
-MA   Mark            -                list of point
-MN   set move number move             number
-N    Nodename        -                simpletext
-OB   OtStones Black  move             number
-ON   Opening         game-info        simpletext
-OT  Overtime        game-info        simpletext
-OW   OtStones White  move             number
-PB   Player Black    game-info        simpletext
-PC   Place           game-info        simpletext
-PL   Player to play  setup            color
-PM  Print move mode - (inherit)      number
-PW   Player White    game-info        simpletext
-RE  Result          game-info        simpletext
-RO   Round           game-info        simpletext
-RU  Rules           game-info        simpletext
-SE  Markup          - (LOA)          point
-SL   Selected        -                list of point
-SO   Source          game-info        simpletext
-SQ  Square          -                list of point
-ST  Style           root	      number (range: 0-3)
-SU  Setup type      game-info (LOA)  simpletext
-SZ  Size            root	      (number | composed number ':' number)
-TB   Territory Black - (Go)           elist of point
-TE   Tesuji          move             double
-TM   Timelimit       game-info        real
-TR   Triangle        -                list of point
-TW   Territory White - (Go)           elist of point
-UC   Unclear pos     -                double
-US   User            game-info        simpletext
-V    Value           -                real
-VW  View            - (inherit)      elist of point
-W    White           move             move
-WL   White time left move             real
-WR   White rank      game-info        simpletext
-WT   White team      game-info        simpletext }
-
-  property_array = property_string.split("\n")
-  hash = {}
-  property_array.each do |set|
-    temp = set.gsub("\t", "        ")
-    id = temp[0..3].strip
-    desc = temp[4..19].strip
-    property_type = temp[20..35].strip
-    property_value = temp[37..-1].strip
-    hash[id] = [desc, property_type, property_value]
+    PROPERTIES = {"annotator"=>"AN",
+                  "black_octisquares"=>"BO", #Octi
+                  "black_rank"=>"BR",
+                  "black_team"=>"BT",
+                  "copyright"=>"CP",
+                  "date"=>"DT",
+                  "event"=>"EV",
+                  "game_content"=>"GC",
+                  "handicap"=>"HA", #Go
+                  "initial_position"=>"IP", #Lines of Action
+                  "invert_y_axis"=>"IY", #Lines of Action
+                  "komi"=>"KM", #Go
+                  "match_information"=>"MI", #Backgammon
+                  "name"=>"GN",
+                  "prongs"=>"NP", #Octi
+                  "reserve"=>"NR", #Octi
+                  "superprongs"=>"NS", #Octi
+                  "opening"=>"ON",
+                  "overtime"=>"OT",
+                  "black_player"=>"PB",
+                  "place"=>"PC",
+                  "puzzle"=>"PZ",
+                  "white_player"=>"PW",
+                  "result"=>"RE",
+                  "round"=>"RO",
+                  "rules"=>"RU",
+                  "setup_type"=>"SU", #Lines of Action
+                  "source"=>"SO",
+                  "time"=>"TM",
+                  "data_entry"=>"US",
+                  "white_octisquares"=>"WO", #Octi
+                  "white_rank"=>"WR",
+                  "white_team"=>"WT"}
   end
 
-  # All this work for this minuscule line!
-  PROPERTIES = hash
+  class Node
+    PROPERTIES = {
+        "black_move" => "B",
+        "black_time_left" => "BL",
+        "bad_move" => "BM",
+        "doubtful" => "DO",
+        "interesting" => "IT",
+        "ko" => "KO",
+        "set_move_number" => "MN",
+        "otstones_black" => "OB", # What?
+        "otstones_white" => "OW", # Again! What?
+        "tesuji" => "TE",
+        "white_move" => "W",
+        "white_time_left" => "WL",
+        "add_black" => "AB",
+        "add_empty" => "AE",
+        "add_white" => "AW",
+        "player" => "PL",
+        "arrow" => "AR",
+        "comment" => "C",
+        "circle" => "CR",
+        "dim_points" => "DD",
+        "even_position" => "DM", #Yep. No idea how that makes sense.
+        "figure" => "FG",
+        "good_for_black" => "GB",
+        "good_for_white" => "GW",
+        "hotspot" => "HO",
+        "label" => "LB",
+        "line" => "LN",
+        "mark" => "MA",
+        "node_name" => "N",
+        "print_move_node" => "PM", #Am I going to have to code this?
+        "selected" => "SL",
+        "square" => "SQ",
+        "triangle" => "TR",
+        "unclear_position" => "UC",
+        "value" => "V",
+        "view" => "VW",
+        "application" => "AP",
+        "charset" => "CA",
+        "file_format" => "FF",
+        "game" => "GM",
+        "style" => "ST",
+        "size" => "SZ"
+    }
+  end
 
 end