sgf_parser 0.1.0

data/lib/sgf.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/sgf/debugger')
+require File.expand_path(File.dirname(__FILE__) + '/sgf/state_machine')
+require File.expand_path(File.dirname(__FILE__) + '/sgf/sgf_state_machine')
+require File.expand_path(File.dirname(__FILE__) + '/sgf/default_event_listener')
+require File.expand_path(File.dirname(__FILE__) + '/sgf/parser')
+require File.expand_path(File.dirname(__FILE__) + '/sgf/parse_error')
+require File.expand_path(File.dirname(__FILE__) + '/sgf/binary_file_error')
+require File.expand_path(File.dirname(__FILE__) + '/sgf/sgf_helper')
+
+require File.expand_path(File.dirname(__FILE__) + '/sgf/model/constants')
+require File.expand_path(File.dirname(__FILE__) + '/sgf/model/property_handler')
+require File.expand_path(File.dirname(__FILE__) + '/sgf/model/event_listener')
+require File.expand_path(File.dirname(__FILE__) + '/sgf/model/game')
+require File.expand_path(File.dirname(__FILE__) + '/sgf/model/node')
+require File.expand_path(File.dirname(__FILE__) + '/sgf/model/label')

data/lib/sgf/binary_file_error.rb

@@ -0,0 +1,4 @@
+module SGF
+  class BinaryFileError < StandardError
+  end
+end

data/lib/sgf/debugger.rb

@@ -0,0 +1,15 @@
+module SGF
+  module Debugger
+    def enable_debug_mode
+      @debug_mode = true
+    end
+    
+    def disable_debug_mode
+      @debug_mode = false
+    end
+    
+    def debug message
+      puts message if @debug_mode
+    end
+  end
+end

data/lib/sgf/default_event_listener.rb

@@ -0,0 +1,37 @@
+module SGF
+  class DefaultEventListener
+    include Debugger
+    
+    def initialize debug_mode = false
+      enable_debug_mode if debug_mode
+    end
+    
+    def start_game
+      debug 'start_game'
+    end
+    
+    def start_node
+      debug 'start_node'
+    end
+    
+    def property_name= name
+      debug "property_name = '#{name}'"
+    end
+    
+    def property_value= value
+      debug "property_value = '#{value}'"
+    end
+    
+    def start_variation
+      debug "start_variation"
+    end
+    
+    def end_variation
+      debug "end_variation"
+    end
+    
+    def end_game
+      debug "end_game"
+    end   
+  end
+end

data/lib/sgf/model/constants.rb

@@ -0,0 +1,19 @@
+module SGF
+  module Model
+    module Constants
+      WEIQI = 1
+      
+      DEFAULT_BOARD_SIZE = 19
+      DEFAULT_KOMI       = 7.5
+      
+      BLACK      = 1
+      WHITE      = 2
+      
+      NODE_SETUP = 0
+      NODE_MOVE  = 1
+      NODE_PASS  = 2
+      
+      POSITIONS = "abcdefghijklmnopqrs"
+    end
+  end
+end

data/lib/sgf/model/event_listener.rb

@@ -0,0 +1,72 @@
+module SGF
+  module Model
+    class EventListener < SGF::DefaultEventListener
+      include SGF::SGFHelper
+      
+      attr_reader :game, :node
+      
+      def initialize debug_mode = false
+        super(debug_mode)
+      end
+      
+      def start_game
+        super
+        
+        @game = Game.new
+      end
+      
+      def start_variation
+        super
+        
+        @node = Node.new(@node)
+        @node.variation_root = true
+      end
+      
+      def end_variation
+        super
+        
+        @node = find_variation_root(@node).parent
+      end
+      
+      def start_node
+        super
+        
+        @node = @node.nil? ? game.root_node : Node.new(@node)
+      end
+      
+      def property_name= name
+        super name
+        
+        @property_name = name
+      end
+      
+      def property_value= value
+        super value
+        
+        set_property @property_name, value
+      end
+      
+      private
+      
+      def find_variation_root node
+        while not node.variation_root?
+          return node if node.parent.nil?
+          
+          node = node.parent
+        end
+        node
+      end
+      
+      def set_property name, value
+        return unless name
+        name = name.strip.upcase
+        value.strip! unless value.nil?
+        
+        return if GAME_PROPERTY_HANDLER.handle(game, name, value)
+        return if NODE_PROPERTY_HANDLER.handle(node, name, value)
+
+        puts "WARNING: SGF property is not recognized(name=#{name}, value=#{value})"
+      end
+    end
+  end
+end

data/lib/sgf/model/game.rb

@@ -0,0 +1,52 @@
+module SGF
+  module Model
+    class Game
+      include Constants
+      include SGF::SGFHelper
+      
+      attr_accessor :game_type, :name, :rule, :board_size, :handicap, :komi, 
+                    :black_player, :black_rank, :white_player, :white_rank,
+                    :black_team, :white_team,
+                    :time_rule, :overtime_rule, :result, 
+                    :played_on, :program, :place, :event, :round, :source,
+                    :annotation, :comment
+
+      def initialize
+        @game_type   = WEIQI
+        @board_size  = DEFAULT_BOARD_SIZE
+        @handicap    = 0
+        @komi        = DEFAULT_KOMI
+      end
+      
+      def misc_properties
+        @misc_properties ||= {}
+      end
+      
+      def game_type=(value);  @game_type  = value.to_i; end
+      def board_size=(value); @board_size = value.to_i; end
+      def handicap=(value);   @handicap   = value.to_i; end
+      def komi=(value);       @komi       = value.to_f; end
+
+      def root_node
+        @root_node ||= Node.new(nil)
+      end
+      
+      def time_rule
+        @time_rule.to_s + (overtime_rule ? " (#{overtime_rule})" : "")
+      end
+      
+      def moves
+        moves = 0
+        
+        node = root_node
+        while node
+          moves = node.move_no
+          node = node.children[0]
+        end
+        
+        moves
+      end
+      
+    end
+  end
+end

data/lib/sgf/model/label.rb

@@ -0,0 +1,12 @@
+class SGF::Model::Label
+  attr_accessor :position, :text
+  
+  def initialize position, text
+    self.position = position
+    self.text     = text
+  end
+  
+  def == other
+    self.position == other.position and self.text == other.text
+  end
+end

data/lib/sgf/model/node.rb

@@ -0,0 +1,115 @@
+module SGF
+  module Model
+    class Node
+      include Constants
+      include SGF::SGFHelper
+      
+      attr_reader :node_type, :color, :move, :black_moves, :white_moves, :labels
+      attr_reader :parent, :children
+      attr_accessor :comment, :whose_turn
+      
+      def initialize parent = nil
+        @parent     = parent
+        @node_type  = NODE_SETUP
+        @labels     = []
+        @whose_turn = BLACK
+        @trunk      = true
+        if parent
+          @trunk = parent.trunk?
+          @parent.children << self
+        end
+      end
+      
+      def move_no
+        parent_move_no = parent.nil? ? 0 : parent.move_no
+        self.node_type == NODE_MOVE ? parent_move_no + 1 : parent_move_no
+      end
+      
+      def misc_properties
+        @misc_properties ||= {}
+      end
+      
+      def whose_turn= input
+        @whose_turn = input.to_i
+      end
+      
+      def black_moves
+        @black_moves ||= []
+      end
+      
+      def white_moves
+        @white_moves ||= []
+      end
+      
+      def clear_moves
+        @white_moves ||= []
+      end
+      
+      def children
+        @children ||= []
+      end
+      
+      def child
+        @children.first
+      end
+      
+      def root?
+        @parent.nil?
+      end
+      
+      def trunk?
+        @trunk
+      end
+      
+      def last?
+        @children.nil? or @children.empty?
+      end
+      
+      def variation_root= value
+        @variation_root = value
+        @trunk = false if value
+      end
+      
+      def variation_root?
+        @variation_root
+      end
+      
+      def sgf_setup_black input
+        to_position_array(input).each {|position| self.black_moves << position}
+      end
+      
+      def sgf_setup_white input
+        to_position_array(input).each {|position| self.white_moves << position}
+      end
+      
+      def sgf_setup_clear input
+        to_position_array(input).each {|position| self.clear_moves << position}
+      end
+      
+      def sgf_play_black input
+        @color = BLACK
+        set_move input
+      end
+      
+      def sgf_play_white input
+        @color = WHITE
+        set_move input
+      end
+      
+      def sgf_label input
+        @labels << to_label(input)
+      end
+      
+      private
+      
+      def set_move input
+        if input.nil? or input.strip.size == 0
+          @node_type = NODE_PASS
+        else
+          @node_type = NODE_MOVE
+          @move      = to_position(input)
+        end
+      end
+    end
+  end
+end

data/lib/sgf/model/property_handler.rb

@@ -0,0 +1,51 @@
+module SGF
+  module Model
+    class PropertyHandler
+      def initialize method_mappings, misc_properties
+        @method_mappings = method_mappings
+        @misc_properties = misc_properties
+      end
+      
+      def handle model, name, value
+        if @method_mappings.include?(name)
+          model.send(@method_mappings[name], value)
+          
+          true
+        elsif @misc_properties.include?(name)
+          if model.misc_properties[name]
+            model.misc_properties[name] = [model.misc_properties[name], value].flatten
+          else
+            model.misc_properties[name] = value
+          end
+
+          true
+        end
+      end
+    end
+      
+    # See http://www.red-bean.com/sgf/properties.html for property definitions
+    GAME_PROPERTY_MAPPINGS = {
+      'GM' => :game_type=, 'GN' => :name=, 'RU' => :rule=, 'SZ' => :board_size=, 'HA' => :handicap=, 'KM' => :komi=,
+      'PW' => :white_player=, 'BR' => :black_rank=, 'PB' => :black_player=, 'WR' => :white_rank=,
+      'BT' => :black_team=, 'WT' => :white_team=,
+      'DT' => :played_on=, 'TM' => :time_rule=, 'OT' => :overtime_rule=,
+      'SY' => :program=, 'RE' => :result=, 'AP' => :program=, 'PC' => :place=, 'EV' => :event=, 'RO' => :round=,
+      'SO' => :source=, 'AN' => :annotation=, 'GC' => :comment=
+    }
+
+    GAME_MISC_PROPERTIES = %w(FF US CA ST)
+
+    NODE_PROPERTY_MAPPINGS = {
+      "B" => :sgf_play_black, "W" => :sgf_play_white, "C" => :comment=,
+      "AB" => :sgf_setup_black, "AW" => :sgf_setup_white, "AE" => :sgf_setup_clear, "LB" => :sgf_label,
+      "PL" => :whose_turn=
+    }
+  
+    NODE_MARK_PROPERTIES = %w(AR CR DD LB LN MA SL SQ TR)
+    NODE_TIME_PROPERTIES = %w(BL WL OB OW TB TW)
+    NODE_MISC_PROPERTIES = %w(N GW GB DM UC TE BM DO IT MN) + NODE_MARK_PROPERTIES + NODE_TIME_PROPERTIES    
+    
+    GAME_PROPERTY_HANDLER = PropertyHandler.new(GAME_PROPERTY_MAPPINGS, GAME_MISC_PROPERTIES)
+    NODE_PROPERTY_HANDLER = PropertyHandler.new(NODE_PROPERTY_MAPPINGS, NODE_MISC_PROPERTIES)
+  end
+end

data/lib/sgf/more/state_machine_presenter.rb

@@ -0,0 +1,43 @@
+# This class is created for illustrative purpose only. It should not be used as 
+# the base class for state machine visualizer
+
+module SGF
+  module More
+    class StateMachinePresenter
+      def nodes
+        nodes_hash.values
+      end
+
+      def edges
+        @edges ||= []
+      end
+
+      def process state_machine
+        nodes_hash[state_machine.start_state.to_s] = create_node(state_machine.start_state.to_s)
+        state_machine.transitions.each do |from_state, transitions|
+          transitions.each do |transition|
+            from_node = nodes_hash[from_state.to_s] ||= create_node(from_state.to_s)
+            to_state = transition.after_state || from_state
+            to_node = nodes_hash[to_state.to_s] ||= create_node(to_state.to_s)
+            transition_desc = transition.description || transition.event_pattern.inspect
+            edges << create_edge(from_node, to_node, transition_desc)
+          end
+        end
+      end
+
+      private
+
+      def nodes_hash
+        @nodes ||= {}
+      end
+
+      def create_node name
+        name
+      end
+
+      def create_edge from_node, to_node, description
+        [from_node, to_node, description]
+      end
+    end
+  end
+end