sgf_parser 0.1.0

data/lib/sgf/more/stm_dot_converter.rb

@@ -0,0 +1,139 @@
+module SGF
+  module More
+    class StmDotConverter
+      
+      STATE_PROPERTIES = {
+        SGF::SGFStateMachine::STATE_BEGIN => {
+          :shape => 'circle', :fillcolor => '#44ff44', :style => 'filled'
+        },
+        SGF::SGFStateMachine::STATE_GAME_BEGIN => {
+        },
+        SGF::SGFStateMachine::STATE_VAR_BEGIN => {
+        },
+        SGF::SGFStateMachine::STATE_VAR_END => {
+        },
+        SGF::SGFStateMachine::STATE_GAME_END => {
+          :label => 'end', :shape => 'doublecircle', :fillcolor => '#44ff44', :style => 'filled'
+        },
+        SGF::SGFStateMachine::STATE_INVALID => {
+          :label => 'error', :shape => 'octagon', :fillcolor => '#ff4444', :style => 'filled'
+        },
+      }
+      
+      EDGE_PROPERTIES = {
+        "begin:game_begin" => {
+          :weight => 100
+        },
+        "game_begin:game_node" => {
+          :weight => 100
+        },
+        "game_node:prop_name_begin" => {
+          :weight => 100
+        },
+        "prop_name_begin:prop_name" => {
+          :weight => 100
+        },
+        "prop_name:value_begin" => {
+          :weight => 100
+        },
+        "value_begin:value" => {
+          :weight => 100
+        },
+        "value:value_end" => {
+          :weight => 100
+        },
+        "value_end:var_end" => {
+          :weight => 100
+        },
+        "var_end:game_node" => {
+          :weight => 100
+        },
+        "var_end:game_end" => {
+          :weight => 100
+        },
+      }
+      
+      def process stm
+        s = "digraph SGF_STATE_MACHINE{"
+        s << graph_attributes
+        s << create_node_for_state(stm.start_state)
+
+        stm.transitions.each do |start_state, transitions|
+          transitions.each do |transition|
+            s << create_edge_for_transition(start_state, transition)
+          end
+        end
+
+        s << "}\n"
+        s
+      end
+      
+      private
+      
+      def graph_attributes
+        '
+        {rank = same; begin;}
+        {rank = same; game_begin;}
+        {rank = same; var_begin game_node;}
+        {rank = same; prop_name_begin;}
+        {rank = same; prop_name;}
+        {rank = same; value_begin;}
+        {rank = same; value value_escape;}
+        {rank = same; value_end;}
+        {rank = same; var_end;}
+        {rank = same; game_end invalid;}
+        '
+      end
+      
+      def create_node_for_state state
+        @processed_states ||= []
+        return "" if @processed_states.include?(state)
+        
+        @processed_states << state
+
+        s = state.to_s + "["
+        properties = STATE_PROPERTIES[state]
+        if properties
+          prop_arr = []
+          properties.each do |key, value|
+            prop_arr << "#{key} = #{value.inspect}"
+          end
+          s << prop_arr.join(',')
+        end
+        s << "];\n"
+      end
+      
+      def create_edge_for_transition start_state, transition
+        s = ""
+        s << create_node_for_state(start_state)
+
+        end_state = transition.after_state || start_state
+        s << create_node_for_state(end_state)
+
+        s << start_state.to_s << " -> " << end_state.to_s << "["
+        if end_state == SGFStateMachine::STATE_INVALID
+          s << "color=\"#FFBBBB\", weight=-100"
+        else
+          s << "label=\"" << (transition.description || pattern_to_label(transition.event_pattern)) << "\"" 
+        end
+        
+        edge_properties = EDGE_PROPERTIES["#{start_state}:#{end_state}"]
+        if edge_properties
+          edge_properties.each do |key, value|
+            s << ", #{key}=#{value.inspect}"
+          end
+        end
+        
+        s << "];\n"
+      end
+      
+      def pattern_to_label pattern
+        if pattern.nil?
+          "EOS"
+        else
+          pattern.inspect[1..-2].gsub("\\", "\\\\")
+        end
+      end
+    end
+  end
+end

data/lib/sgf/parse_error.rb

@@ -0,0 +1,25 @@
+module SGF
+  class ParseError < StandardError
+    attr_reader :input, :position, :description
+    
+    def initialize input, position, description = nil
+      @input = input
+      @position = position
+      @description = description || "SGF parse error occurred here "
+    end
+    
+    def to_s
+      if @position > 1000
+        start_position = @position - 1000
+        s = '...'
+      else
+        start_position = 0
+        s = ''
+      end
+      s << @input[start_position..@position]
+      s << ' <=== '
+      s << description.to_s
+    end
+
+  end
+end

data/lib/sgf/parser.rb

@@ -0,0 +1,56 @@
+module SGF
+  class Parser    
+    attr_reader :event_listener
+    
+    def initialize event_listener
+      @event_listener = event_listener
+      @stm = SGFStateMachine.new
+      @stm.context = event_listener
+    end
+    
+    def parse input
+      @stm.reset
+      
+      raise ArgumentError.new if input.nil? or input.strip.empty?
+      
+      input.strip!
+        
+      0.upto(input.size - 1) do |i|
+        @position = i
+        @stm.event(input[i,1])
+      end
+      
+      @stm.end
+    rescue StateMachineError => e
+      raise ParseError.new(input, @position, e.message)
+    end
+    
+    def parse_file filename
+      raise BinaryFileError if Parser.is_binary?(filename)
+      File.open(filename) do |f|
+        parse f.readlines.join
+      end
+    end
+    
+    class << self
+      def parse input, debug = false
+        parser = SGF::Parser.new(SGF::Model::EventListener.new(debug))
+        parser.parse input
+        parser.event_listener.game
+      end
+    
+      def parse_file filename, debug = false
+        parser = SGF::Parser.new(SGF::Model::EventListener.new(debug))
+        parser.parse_file filename
+        parser.event_listener.game
+      end
+      
+      def is_binary? file
+        # This does not work?!
+        # parts = %x(/usr/bin/file -i #{file}).split(':', 2)
+        # not parts[1].include?('text')
+      end
+    end
+
+  end
+end

data/lib/sgf/renderer.rb

@@ -0,0 +1,25 @@
+module SGF
+  # Renderer is called by a client program to render client object in SGF format.
+  class Renderer
+      
+    def render_node node
+      raise 'INCOMPLETE'
+      result = ""
+      
+      if type == NODE_SETUP
+        unless black_moves.empty?
+        end
+        
+        unless white_moves.empty?
+        end
+        
+      else
+        result << (color == BLACK ? "B" : "W")
+        result << "[" << "" << "]"
+      end
+      
+      result << "C[" << comment << "]" unless comment.nil?
+      result
+    end
+  end
+end

data/lib/sgf/sgf_helper.rb

@@ -0,0 +1,55 @@
+module SGF
+  module SGFHelper
+    def xy_to_sgf_pos x, y
+      SGF::Model::Constants::POSITIONS[x, 1] + SGF::Model::Constants::POSITIONS[y, 1]
+    end
+
+    def move_to_sgf color, x, y
+      return "" unless [SGF::Model::Constants::BLACK, SGF::Model::Constants::WHITE].include?(color)
+
+      sgf = ";"
+      sgf << (color == SGF::Model::Constants::WHITE ? "W" : "B")
+      sgf << "["
+      sgf << xy_to_sgf_pos(x, y)
+      sgf << "]"
+    end
+
+    def to_position_array input
+      raise ArgumentError.new(input) if input.nil? or input !~ /^\s*\w\w(:\w\w)?\s*$/
+
+      input.strip!
+      input.downcase!
+      
+      if input.include?(':')
+        parts = input.split(':', 2)
+        position1 = to_position(parts[0])
+        position2 = to_position(parts[1])
+        positions = []
+        (position1[0]..position2[0]).each do |i|
+          (position1[1]..position2[1]).each do |j|
+            positions << [i, j]
+          end
+        end
+        positions
+      else
+        [to_position(input)]
+      end
+    end
+    
+    def to_position input
+      raise ArgumentError.new(input) if input.nil? or input.strip.length != 2
+      
+      input.strip!
+      input.downcase!
+      
+      [input[0] - ?a, input[1] - ?a]
+    end
+    
+    def to_label input
+      raise ArgumentError.new(input) if input.nil? or input !~ /^\s*\w\w:\w+\s*$/
+      
+      position, text = input.split(':', 2)
+      SGF::Model::Label.new(to_position(position), text.strip)
+    end
+  end
+end

data/lib/sgf/sgf_state_machine.rb

@@ -0,0 +1,174 @@
+module SGF
+  class StateMachineError < StandardError
+  end
+  
+  class SGFStateMachine < StateMachine
+    
+    STATE_BEGIN           = :begin
+    STATE_GAME_BEGIN      = :game_begin       
+    STATE_GAME_END        = :game_end
+    STATE_NODE            = :game_node             
+    STATE_VAR_BEGIN       = :var_begin        
+    STATE_VAR_END         = :var_end     
+    STATE_PROP_NAME_BEGIN = :prop_name_begin
+    STATE_PROP_NAME       = :prop_name        
+    STATE_VALUE_BEGIN     = :value_begin      
+    STATE_VALUE           = :value            
+    STATE_VALUE_ESCAPE    = :value_escape
+    STATE_VALUE_END       = :value_end
+    STATE_INVALID         = :invalid
+    
+    def initialize
+      super(STATE_BEGIN)
+
+      start_game             = lambda{ |stm| return if stm.context.nil?; stm.context.start_game }
+      end_game               = lambda{ |stm| return if stm.context.nil?; stm.context.end_game }
+      start_node             = lambda{ |stm| return if stm.context.nil?; stm.context.start_node }
+      start_variation        = lambda{ |stm| return if stm.context.nil?; stm.context.start_variation }
+      store_input_in_buffer  = lambda{ |stm| return if stm.context.nil?; stm.buffer = stm.input }
+      append_input_to_buffer = lambda{ |stm| return if stm.context.nil?; stm.buffer += stm.input }
+      set_property_name      = lambda{ |stm| return if stm.context.nil?; stm.context.property_name = stm.buffer; stm.clear_buffer }
+      set_property_value     = lambda{ |stm| return if stm.context.nil?; stm.context.property_value = stm.buffer; stm.clear_buffer }
+      end_variation          = lambda{ |stm| return if stm.context.nil?; stm.context.end_variation }
+      report_error           = lambda{ |stm| raise StateMachineError.new('SGF Error near "' + stm.input + '"') }
+
+      transition STATE_BEGIN,        
+                     /\(/,        
+                     STATE_GAME_BEGIN,
+                     start_game
+                           
+      transition [STATE_GAME_BEGIN, STATE_VAR_END, STATE_VALUE_END],   
+                     /;/,
+                     STATE_NODE,
+                     start_node
+      
+      transition STATE_VAR_BEGIN,
+                     /;/,
+                     STATE_NODE
+      
+      transition [STATE_NODE, STATE_VAR_END, STATE_VALUE_END],
+                     /\(/,        
+                     STATE_VAR_BEGIN,
+                     start_variation
+      
+      transition [STATE_NODE, STATE_VALUE_END],
+                     /[a-zA-Z]/,  
+                     STATE_PROP_NAME_BEGIN,
+                     store_input_in_buffer
+      
+      transition [STATE_PROP_NAME_BEGIN, STATE_PROP_NAME],
+                     /[a-zA-Z]/,
+                     STATE_PROP_NAME,
+                     append_input_to_buffer
+      
+      transition [STATE_PROP_NAME_BEGIN, STATE_PROP_NAME],    
+                     /\[/,        
+                     STATE_VALUE_BEGIN,
+                     set_property_name
+        
+      transition STATE_VALUE_END,
+                     /\[/,        
+                     STATE_VALUE_BEGIN
+                     
+      transition STATE_VALUE_BEGIN,
+                     /[^\]]/,
+                     STATE_VALUE,
+                     store_input_in_buffer
+                       
+      transition [STATE_VALUE_BEGIN, STATE_VALUE],
+                     /\\/,
+                     STATE_VALUE_ESCAPE
+                       
+      transition STATE_VALUE_ESCAPE,
+                     /./,
+                     STATE_VALUE,
+                     append_input_to_buffer
+                       
+      transition STATE_VALUE,
+                     /[^\]]/,
+                     nil,
+                     append_input_to_buffer
+                       
+      transition [STATE_VALUE_BEGIN, STATE_VALUE],        
+                     /\]/,        
+                     STATE_VALUE_END,
+                     set_property_value
+                       
+      transition STATE_VAR_END,        
+                     nil,        
+                     STATE_GAME_END,
+                     end_game
+    
+      transition [STATE_NODE, STATE_VALUE_END, STATE_VAR_END],
+                     /\)/,        
+                     STATE_VAR_END,
+                     end_variation
+
+      transition [STATE_BEGIN, STATE_GAME_BEGIN, STATE_NODE, STATE_VAR_BEGIN, STATE_VAR_END, STATE_PROP_NAME_BEGIN, STATE_PROP_NAME, STATE_VALUE_END],
+                     /[^\s]/, 
+                     STATE_INVALID,
+                     report_error
+    end
+
+#    # Overwrite parent to get better performance!
+#    def event input
+#      case @state
+#        when STATE_NODE
+#          if input > "A" and input < "Z" or input > "a" and input < "z"
+#            @state = STATE_PROP_NAME_BEGIN
+#            self.buffer = input
+#            return
+#          end
+#        when STATE_VALUE_BEGIN
+#          if input == "]"
+#            self.state = STATE_VALUE_END
+#            context.property_value = buffer if context
+#            clear_buffer
+#            return
+#          elsif input != "\\"
+#            self.state = STATE_VALUE
+#            self.buffer = input
+#            return
+#          end
+#        when STATE_VALUE
+#          if input == "]"
+#            self.state = STATE_VALUE_END
+#            context.property_value = buffer if context
+#            clear_buffer
+#            return
+#          elsif input != "\\"
+#            self.buffer += input
+#            return
+#          end
+#        when STATE_VALUE_END
+#          if input == "\n"
+#            return
+#          elsif input == ";"
+#            self.state = STATE_NODE
+#            context.start_node if context
+#            return
+#          elsif input > "A" and input < "Z" or input > "a" and input < "z"
+#            @state = STATE_PROP_NAME_BEGIN
+#            self.buffer = input
+#            return
+#          end
+#        when STATE_PROP_NAME_BEGIN, STATE_PROP_NAME
+#          if input == "["
+#            self.state = STATE_VALUE_BEGIN
+#            context.property_name = buffer if context
+#            clear_buffer
+#          else
+#            self.buffer += input
+#          end
+#          return
+#        when STATE_VALUE_ESCAPE
+#          self.state = STATE_VALUE
+#          self.buffer += input
+#          return
+#      end
+#
+#      #puts input.inspect
+#      super input
+#    end
+  end
+end