SgfParser 2.0.0 → 3.0.0

data/lib/sgf/error_checkers.rb

@@ -0,0 +1,15 @@
+class SGF::StrictErrorChecker
+  def check_for_errors_before_parsing string
+    unless string[/\A\s*\(\s*;/]
+      msg = "The first two non-whitespace characters of the string should be (;"
+      msg << " but they were #{string[0..1]} instead."
+      raise(SGF::MalformedDataError, msg)
+    end
+  end
+end
+
+class SGF::LaxErrorChecker
+  def check_for_errors_before_parsing string
+    # just look the other way
+  end
+end

data/lib/sgf/gametree.rb

@@ -0,0 +1,64 @@
+require_relative 'writer'
+
+class SGF::Gametree
+  include Enumerable
+
+  SGF::Gametree::PROPERTIES.each do |human_readable_method, sgf_identity|
+    define_method(human_readable_method.to_sym) do
+      @root[sgf_identity] || raise(SGF::NoIdentityError, "This gametree does not have '#{human_readable_method}' available")
+    end
+  end
+
+  attr_reader :root
+
+  attr_accessor :current_node
+
+  # Takes a SGF::Node as an argument. It will be a problem if that node isn't
+  # really the first node of of a game (ie: no FF property)
+  def initialize node
+    raise ArgumentError, "Expected SGF::Node argument but received #{node.class}" unless node.instance_of? SGF::Node
+    @root = node
+    @current_node = node
+  end
+
+  # A simple way to go to the next node in the same branch of the tree
+  def next_node
+    @current_node = @current_node.children[0]
+  end
+
+  # Iterate through all the nodes in preorder fashion
+  def each &block
+    @root.each(&block)
+  end
+
+  def inspect
+    "<SGF::Gametree:#{object_id}>"
+  end
+
+  def to_s
+    SGF::Writer.new.stringify_tree_from @root
+  end
+
+  def slice range
+    new_root = nil
+    each do |node|
+      if node.depth == range.begin
+        new_root = node.dup
+        break
+      end
+    end
+
+    new_root ||= @root.dup
+    new_root.depth = 0
+    new_root.parent = nil
+    SGF::Gametree.new new_root
+  end
+
+  private
+
+  def method_missing method_name, *args
+    human_readable_method = method_name.to_s.downcase
+    sgf_identity = SGF::Gametree::PROPERTIES[human_readable_method]
+    return @root[sgf_identity] || raise(SGF::NoIdentityError, "This gametree does not have '#{human_readable_method}' available")
+  end
+end

data/lib/sgf/node.rb

@@ -1,109 +1,165 @@
-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 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
-      add_properties args[:properties] if args[:properties]
-    end
+require 'observer'
+# Your basic node. It holds information about itself, its parent, and its children.
+class SGF::Node
+  include Enumerable, Observable
+
+  attr_accessor :children, :properties
+  attr_reader :parent, :depth
+
+  # Creates a new node. You can pass in a hash. There are two special keys, parent and children.
+  # * parent: parent_node (nil by default)
+  # * children: [list, of, children] (empty array if nothing is passed)
+  # Anything else passed to the hash will become an SGF identity/property pair on the node.
+  def initialize children: [], parent: nil, **opts
+    # opts = { children: [], parent: nil }
+    # opts.merge! args
+    @depth = 0
+    @children = []
+    @properties = {}
+    @parent = nil
+    set_parent parent #opts.delete :parent
+    add_children children #opts.delete :children
+    add_properties opts
+  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 do |node|
-        node.parent = self
-        @children << node
-      end
+  # Set the given node as a parent and self as one of that node's children
+  def parent= parent
+    if @parent
+      @parent.children.delete self
+      @parent.delete_observer self
     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 |identity, property|
-        @properties[identity] ||= property.class.new
-        @properties[identity].concat property
-      end
-      update_human_readable_methods
+    case @parent = parent
+    when nil then set_depth 0
+    else
+      @parent.children << self
+      @parent.add_observer self
+      set_depth @parent.depth + 1
     end
+  end
 
-    #Iterate through each child. Yields a child node, if one exists.
-    def each_child
-      @children.each { |child| yield child }
-    end
+  alias :set_parent :parent=
 
-    #Compare to another node.
-    def == other_node
-      @properties == other_node.properties
-    end
+  def remove_parent
+    set_parent nil
+  end
+
+  def depth= new_depth
+    @depth = new_depth
+    changed
+    notify_observers :depth_change, @depth
+  end
+
+  alias :set_depth :depth=
 
-    #Syntactic sugar for node.properties["XX"]
-    def [] identity
-      identity = identity.to_s
-      @properties[identity]
+  # 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.each do |node|
+      node.set_parent self
     end
+    changed
+    notify_observers :new_children, nodes.flatten
+  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 << ">"
+  # 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 |identity, property|
+      @properties[flexible identity] ||= property.class.new
+      @properties[flexible identity].concat property
     end
+    update_human_readable_methods
+  end
 
-    alias :inspect :to_s
+  def each &block
+    preorder self, &block
+  end
 
-    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}")}"
+  # Iterate through and yield each child.
+  def each_child
+    @children.each { |child| yield child }
+  end
+
+  # Compare to another node.
+  def == other_node
+    @properties == other_node.properties
+  end
+
+  # Syntactic sugar for node.properties["XX"]
+  def [] identity
+    @properties[flexible(identity)]
+  end
+
+  def []= identity, new_value
+    @properties[flexible(identity)] = new_value
+  end
+
+  def inspect
+    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
+
+  def to_s(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}]"
+  # Observer pattern
+  def update(message, data)
+    case message
+      when :depth_change then set_depth(data + 1)
     end
+  end
 
-    private
+  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
+  def flexible id
+    id.to_s.upcase
+  end
+
+  def update_human_readable_methods
+    SGF::Node::PROPERTIES.reject do
+      |method_name, sgf_identity| defined? method_name
+    end.each do |human_readable_method, sgf_identity|
+      define_method(human_readable_method.to_sym) do
+        @properties[sgf_identity] ? @properties[sgf_identity] : raise(SGF::NoIdentityError, "This node does not have #{sgf_identity} available")
       end
     end
+  end
 
-    def leading_whitespace(indent)
-      "#{" " * indent}"
+  def preorder node=self, &block
+    yield node
+    node.each_child do |child|
+      preorder child, &block
     end
+  end
 
-    def method_missing method_name, *args
-      property = method_name.to_s.upcase
-      if property[/(.*?)=$/]
-        @properties[$1] = args[0]
-      else
-        output = @properties[property]
-        super(method_name, args) if output.nil?
-        output
-      end
+  def leading_whitespace(indent)
+    ' ' * indent
+  end
+
+  def method_missing method_name, *args
+    property = flexible(method_name)
+    if property[/(.*?)=$/]
+      @properties[$1] = args[0]
+    else
+      @properties.fetch(property, nil) || super(method_name, args)
     end
+  end
 
+  def stringify_identity_and_property(identity, property)
+    new_property = property.instance_of?(Array) ? property.join("][") : property
+    new_id = flexible identity
+    new_property = new_property.gsub("]", "\\]") if new_id == "C"
+    "#{new_id}[#{new_property}]"
   end
 
-end
+end

data/lib/sgf/parser.rb

@@ -1,167 +1,67 @@
-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
-
-    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
+require_relative 'collection_assembler'
+require_relative 'parsing_tokens'
+require_relative 'error_checkers'
+require_relative 'stream'
+
+# The parser returns a SGF::Collection representation of the SGF file
+# parser = SGF::Parser.new
+# collection = parser.parse sgf_in_string_form
+class SGF::Parser
+  NEW_NODE = ";"
+  BRANCHING = %w{( )}
+  END_OF_FILE = false
+  NODE_DELIMITERS = [NEW_NODE].concat(BRANCHING).concat([END_OF_FILE])
+  PROPERTY = %w([ ])
+  LIST_IDENTITIES = %w(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::Collection 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
+    error_checker = strict_parsing ? SGF::StrictErrorChecker.new : SGF::LaxErrorChecker.new
+    @sgf_stream = SGF::Stream.new(sgf, error_checker)
+    @assembler = SGF::CollectionAssembler.new
+    until @sgf_stream.eof?
+      case @sgf_stream.next_character
+      when "(" then @assembler.open_branch
+      when ";" then
+        parse_node_data
+        @assembler.create_node_with_properties @node_properties
+      when ")" then @assembler.close_branch
+      else next
       end
-      @tree
-    end
-
-    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 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
-    end
-
-    def clean sgf
-      sgf.gsub! "\\\\n\\\\r", ''
-      sgf.gsub! "\\\\r\\\\n", ''
-      sgf.gsub! "\\\\r", ''
-      sgf.gsub! "\\\\n", ''
-      sgf
-    end
-
-    def open_branch
-      @branches.unshift @current_node
-    end
-
-    def close_branch
-      @current_node = @branches.shift
-    end
-
-    def create_new_node
-      node = Node.new
-      @current_node.add_children node
-      @current_node = node
-    end
-
-    def parse_node_data
-      @node_properties = {}
-      while still_inside_node?
-        parse_identity
-        parse_property
-        @node_properties[@identity] = @property
-      end
-    end
-
-    def add_properties_to_current_node
-      @current_node.add_properties @node_properties
-    end
-
-    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 parse_identity
-      @identity = ""
-      while char = next_character and char != "["
-        @identity << char unless char == "\n"
-      end
-    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
-
-    def parse_comment
-      while char = next_character and still_inside_comment? char
-        @property << char
-      end
-      @property.gsub! "\\]", "]"
-    end
-
-    def parse_multi_property
-      while char = next_character and still_inside_multi_property? char
-        @property << char
-      end
-      @property = @property.gsub("][", ",").split(",")
     end
+    @assembler.collection
+  end
 
-    def parse_generic_property
-      while char = next_character and char != "]"
-        @property << char
+  private
+
+  def parse_node_data
+    @node_properties = {}
+    while still_inside_node?
+      identity = @sgf_stream.read_token SGF::IdentityToken.new
+      property_format = property_token_type identity
+      property = @sgf_stream.read_token property_format
+      if @node_properties[identity]
+        @node_properties[identity].concat property
+        @assembler.add_error "Multiple #{identity} identities are present in a single node. A property should only exist once per node."
+      else
+        @node_properties[identity] = property
       end
     end
+  end
 
-    def still_inside_comment? char
-      char != "]" || (char == "]" && @property[-1..-1] == "\\")
-    end
-
-    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 still_inside_node?
+    !NODE_DELIMITERS.include?(@sgf_stream.peek_skipping_whitespace)
+  end
 
-    def next_character
-      !@stream.eof? && @stream.sysread(1)
+  def property_token_type identity
+    case identity.upcase
+    when "C" then SGF::CommentToken.new
+    when *LIST_IDENTITIES then SGF::MultiPropertyToken.new
+    else SGF::GenericPropertyToken.new
     end
-
   end
-
 end
-