sgf_parser 0.1.0

data/spec/sgf/sgf_helper_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module SGF
+  describe SGFHelper do
+    before :each do
+      @helper = Object.new.extend(SGFHelper)
+    end
+
+    describe "xy_to_sgf_pos" do
+      it "should convert x,y to sgf position string like ab" do
+        @helper.xy_to_sgf_pos(1, 2).should == "bc"
+      end
+    end
+
+    describe "move_to_sgf" do
+      it "should convert color, x, y to sgf like ;B[ab]" do
+        @helper.move_to_sgf(1, 1, 2).should == ";B[bc]"
+      end
+    end
+    
+    describe "to_position_array" do
+      
+      [nil, "", "  ", "A", "ABC"].each do |bad_argument|
+        it "should throw ArgumentError on bad argument(#{bad_argument.inspect})" do
+          lambda { @helper.to_position_array(bad_argument) }.should raise_error(ArgumentError)
+        end
+      end
+
+      it "should convert AB to [[0, 1]]" do
+        @helper.to_position_array("AB").should == [[0, 1]]
+      end
+
+      it "should be case insensitive" do
+        @helper.to_position_array("ab").should == [[0, 1]]
+        @helper.to_position_array("aB").should == [[0, 1]]
+        @helper.to_position_array("Ab").should == [[0, 1]]
+        @helper.to_position_array("AB").should == [[0, 1]]
+      end
+      
+      it "should ignore leading and trailing spaces" do
+        @helper.to_position_array(" AB").should == [[0, 1]]
+        @helper.to_position_array("AB ").should == [[0, 1]]
+        @helper.to_position_array(" AB ").should == [[0, 1]]
+      end
+      
+      it "should convert AB:BC to [[0,1], [0,2], [1,1], [1,2]]" do
+        @helper.to_position_array("AB:BC").should == [[0,1], [0,2], [1,1], [1,2]]
+      end
+        
+    end
+    
+    describe "to_position" do
+      it "should convert AB to [0, 1]" do
+        @helper.to_position("AB").should == [0, 1]
+      end
+
+      it "should be case insensitive" do
+        @helper.to_position("ab").should == [0, 1]
+      end
+    end
+    
+    describe "to_label" do
+      it "should return label" do
+        @helper.to_label("AB:C").should == SGF::Model::Label.new(@helper.to_position("AB"), "C")
+      end
+    end
+  end
+end

data/spec/sgf/sgf_state_machine_spec.rb

@@ -0,0 +1,166 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module SGF
+  describe SGFStateMachine do
+    describe "with no context" do
+      before :each do
+        @stm = SGFStateMachine.new
+      end
+
+      it "should return state machine for sgf" do
+        @stm.class.should == SGFStateMachine
+      end
+
+      it "should have start_state of #{SGFStateMachine::STATE_BEGIN}" do
+        @stm.start_state.should == SGFStateMachine::STATE_BEGIN
+      end
+    
+      [
+        [SGFStateMachine::STATE_BEGIN,         '(', SGFStateMachine::STATE_GAME_BEGIN],
+        [SGFStateMachine::STATE_GAME_BEGIN,    ';', SGFStateMachine::STATE_NODE],
+        [SGFStateMachine::STATE_NODE,          'A', SGFStateMachine::STATE_PROP_NAME_BEGIN],
+        [SGFStateMachine::STATE_NODE,          ')', SGFStateMachine::STATE_VAR_END],
+        [SGFStateMachine::STATE_PROP_NAME,     'A', SGFStateMachine::STATE_PROP_NAME],
+        [SGFStateMachine::STATE_PROP_NAME,     '[', SGFStateMachine::STATE_VALUE_BEGIN],
+        [SGFStateMachine::STATE_VALUE_BEGIN,   'A', SGFStateMachine::STATE_VALUE],
+        [SGFStateMachine::STATE_VALUE_BEGIN,   ']', SGFStateMachine::STATE_VALUE_END],
+        [SGFStateMachine::STATE_VALUE,         ']', SGFStateMachine::STATE_VALUE_END],
+        [SGFStateMachine::STATE_VALUE,         '\\', SGFStateMachine::STATE_VALUE_ESCAPE],
+        [SGFStateMachine::STATE_VALUE_ESCAPE,  ']', SGFStateMachine::STATE_VALUE],
+        [SGFStateMachine::STATE_VALUE_END,     ';', SGFStateMachine::STATE_NODE],
+        [SGFStateMachine::STATE_VALUE_END,     '(', SGFStateMachine::STATE_VAR_BEGIN],
+        [SGFStateMachine::STATE_VALUE_END,     ')', SGFStateMachine::STATE_VAR_END],
+        [SGFStateMachine::STATE_VALUE_END,     'A', SGFStateMachine::STATE_PROP_NAME_BEGIN],
+        [SGFStateMachine::STATE_VAR_BEGIN,     ';', SGFStateMachine::STATE_NODE],
+        [SGFStateMachine::STATE_VAR_END,       ';', SGFStateMachine::STATE_NODE],
+        [SGFStateMachine::STATE_VAR_END,       '(', SGFStateMachine::STATE_VAR_BEGIN]
+      ].each do |state_before, input, state_after|
+        it "should have transition for '#{state_before}' + '#{input}' => '#{state_after}'" do
+          @stm.state = state_before
+          @stm.event input
+          @stm.state.should == state_after
+        end
+      end
+      
+      it "end should trigger transition to game_end" do
+        @stm.state = SGFStateMachine::STATE_VAR_END
+        @stm.end
+        @stm.state.should == SGFStateMachine::STATE_GAME_END
+      end
+      
+      it "should handle escaped characters" do
+        @stm.state = SGFStateMachine::STATE_VALUE
+        @stm.event '\\'
+        @stm.state.should == SGFStateMachine::STATE_VALUE_ESCAPE
+        @stm.event ']'
+        @stm.state.should == SGFStateMachine::STATE_VALUE
+      end
+      
+      [
+        [SGFStateMachine::STATE_BEGIN           , 'A'],
+        [SGFStateMachine::STATE_GAME_BEGIN      , '['],
+        [SGFStateMachine::STATE_NODE            , '['],
+        [SGFStateMachine::STATE_VAR_BEGIN       , '['],
+        [SGFStateMachine::STATE_VAR_END         , '['],
+        [SGFStateMachine::STATE_PROP_NAME_BEGIN , ']'],
+        [SGFStateMachine::STATE_PROP_NAME       , ']'],
+        [SGFStateMachine::STATE_VALUE_END       , ']'],
+      ].each do |state_before, input|
+        it "should raise error for '#{state_before}' + '#{input}'" do
+          @stm.state = state_before
+          lambda {
+            @stm.event input
+          }.should raise_error
+        end
+      end
+    end
+  
+    describe "with context" do
+      before :each do
+        @context = Object.new
+        @stm = SGFStateMachine.new
+        @stm.context = @context
+        @stm.reset
+      end
+      
+      it "Transition to game begin should call context.start_game" do
+        mock(@context).start_game
+        @stm.state = SGFStateMachine::STATE_BEGIN
+        @stm.event "("
+      end
+      
+      it "Transition to node should call context.start_node" do
+        mock(@context).start_node
+        @stm.state = SGFStateMachine::STATE_GAME_BEGIN
+        @stm.event ";"
+      end
+      
+      it "Transition to variation begin should call context.start_variation" do
+        mock(@context).start_variation
+        @stm.state = SGFStateMachine::STATE_NODE
+        @stm.event "("
+      end
+      
+      it "Transition to prop name begin should set store input to buffer" do
+        @stm.state = SGFStateMachine::STATE_NODE
+        @stm.event "A"
+        @stm.buffer.should == "A"
+      end
+
+      it "Transition to prop name from prop name begin should append input to buffer" do
+        @stm.buffer = "A"
+        @stm.state = SGFStateMachine::STATE_PROP_NAME_BEGIN
+        @stm.event "B"
+        @stm.buffer.should == "AB"
+      end
+      
+      it "Transition to game variation end should call context.end_variation" do
+        mock(@context).end_variation
+        @stm.state = SGFStateMachine::STATE_VALUE_END
+        @stm.event ")"
+      end
+      
+      it "Transition to value begin should call context.property_name= with buffer" do
+        mock(@context).property_name = "AB"
+        @stm.buffer = "AB"
+        @stm.state = SGFStateMachine::STATE_PROP_NAME
+        @stm.event "["
+      end
+      
+      it "Transition to value should store input to buffer" do
+        @stm.buffer = "AB"
+        @stm.state = SGFStateMachine::STATE_VALUE_BEGIN
+        @stm.event "V"
+        @stm.buffer.should == "V"
+      end
+
+      it "Transition from value escape to value should store input to buffer" do
+        @stm.buffer = "AB"
+        @stm.state = SGFStateMachine::STATE_VALUE_ESCAPE
+        @stm.event "V"
+        @stm.buffer.should == "ABV"
+      end
+      
+      it "Transition to value from value should append input to buffer" do
+        @stm.buffer = "Valu"
+        @stm.state = SGFStateMachine::STATE_VALUE
+        @stm.event "e"
+        @stm.buffer.should == "Value"
+      end
+      
+      it "Transition to value end should call context.property_value" do
+        mock(@context).property_value = "Value"
+        @stm.buffer = "Value"
+        @stm.state = SGFStateMachine::STATE_VALUE
+        @stm.event "]"
+      end
+      
+      it "Transition to node from variation begin should not create node" do
+        dont_allow(@context).start_node
+        @stm.state = SGFStateMachine::STATE_VAR_BEGIN
+        @stm.event ";"
+      end
+    end
+    
+  end
+end

data/spec/sgf/state_machine_spec.rb

@@ -0,0 +1,137 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module SGF
+  describe StateMachine do
+    before :each do
+      @stm = StateMachine.new :start
+    end
+        
+    it "state should return current state" do
+      @stm.state.should == :start
+    end
+    
+    it "transition should create transition" do
+      callback = lambda{}
+      @stm.transition :start, /a/, :end, callback
+      
+      t = @stm.transitions[:start][0]
+      t.before_state.should == :start
+      t.event_pattern.should == /a/
+      t.after_state.should == :end
+      t.callback.should == callback
+    end
+    
+    it "transition should create multiple transitions for multiple start states" do
+      @stm.transition [:start, :start2], /a/, :end
+      
+      t = @stm.transitions[:start][0]
+      t.before_state.should == :start
+      t.event_pattern.should == /a/
+      t.after_state.should == :end
+      t2 = @stm.transitions[:start2][0]
+      t2.before_state.should == :start2
+      t2.event_pattern.should == /a/
+      t2.after_state.should == :end
+    end
+    
+    it "transition_if should create transition with condition" do
+      condition = lambda{}
+      @stm.transition_if condition, :start, /a/, :end
+      
+      t = @stm.transitions[:start][0]
+      t.condition.should == condition
+      t.before_state.should == :start
+      t.event_pattern.should == /a/
+      t.after_state.should == :end
+    end
+    
+    it "transition_if should create multiple transitions for multiple start states" do
+      condition = lambda{}
+      @stm.transition_if condition, [:start, :start2], /a/, :end
+      
+      t = @stm.transitions[:start][0]
+      t.condition.should == condition
+      t.before_state.should == :start
+      t2 = @stm.transitions[:start2][0]
+      t2.condition.should == condition
+      t2.before_state.should == :start2
+    end
+    
+    it "desc should set description for next transition" do
+      @stm.desc 'conditional transition'
+      @stm.transition [:start, :start2], /a/, :end
+      
+      @stm.transitions[:start][0].description.should == 'conditional transition'
+      @stm.transitions[:start2][0].description.should == 'conditional transition'
+    end
+    
+    it "desc should not description for transition after next transition" do
+      @stm.desc 'conditional transition'
+      @stm.transition [:start, :start2], /a/, :end
+      @stm.transition :start3, /a/, :end
+      
+      @stm.transitions[:start3][0].description.should be_nil
+    end
+    
+    it "reset should reset its state to start state" do
+      @stm.transition :start, /.*/, :end
+      @stm.event('a').should be_true
+      @stm.state.should == :end
+      
+      @stm.reset
+      
+      @stm.state.should == :start
+    end
+    
+    it "event should trigger state transition and return true if match the pattern" do
+      @stm.transition :start, /.*/, :end
+      @stm.event('a').should be_true
+      @stm.state.should == :end
+    end
+    
+    it "event should return false if no transition is defined for state" do
+      @stm.event('a').should be_false
+    end
+    
+    it "event should trigger state transition if current state is any of transition's start states and input match the pattern" do
+      @stm.transition [:start, :another], /.*/, :end
+      @stm.event 'a'
+      @stm.state.should == :end
+      @stm.instance_variable_set(:'@state', :another)
+      @stm.event 'a'
+      @stm.state.should == :end
+    end
+    
+    it "event should not trigger state transition and return false if it does not match the pattern" do
+      @stm.transition :start, /a/, :end
+      @stm.event('b').should be_false
+      @stm.state.should == :start
+    end
+    
+    it "event should not trigger state transition and return false if condition is not met" do
+      @stm.transition_if lambda{false}, :start, /a/, :end
+      @stm.event('a').should be_false
+      @stm.state.should == :start
+    end
+    
+    it "nil means end of input" do
+      @stm.transition :start, nil, :end
+      @stm.end
+      @stm.state.should == :end
+    end
+    
+    it "transition should invoke the lambda if triggered by an event" do
+      @stm.buffer = "123"
+      @stm.transition :start, /4/, :end, lambda{|stm| @stm.buffer += @stm.input }
+      @stm.event '4'
+      @stm.buffer.should == "1234"
+    end
+    
+    it "clear_buffer should clear buffer" do
+      @stm.buffer = "abc"
+      @stm.clear_buffer
+      @stm.buffer.should == ""
+    end
+    
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+$:.push(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'spec'
+
+Spec::Runner.configure do |config|
+  # If you're not using ActiveRecord you should remove these
+  # lines, delete config/database.yml and disable :active_record
+  # in your config/boot.rb
+  # config.use_transactional_fixtures = true
+  # config.use_instantiated_fixtures  = false
+  # config.fixture_path = RAILS_ROOT + '/../spec/fixtures/'
+
+  # == Fixtures
+  #
+  # You can declare fixtures for each example_group like this:
+  #   describe "...." do
+  #     fixtures :table_a, :table_b
+  #
+  # Alternatively, if you prefer to declare them only once, you can
+  # do so right here. Just uncomment the next line and replace the fixture
+  # names with your fixtures.
+  #
+  # config.global_fixtures = :table_a, :table_b
+  #
+  # If you declare global fixtures, be aware that they will be declared
+  # for all of your examples, even those that don't use them.
+  #
+  # You can also declare which fixtures to use (for example fixtures for test/fixtures):
+  #
+  # config.fixture_path = RAILS_ROOT + '/spec/fixtures/'
+  #
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  config.mock_with :rr
+  #
+  # == Notes
+  # 
+  # For more information take a look at Spec::Example::Configuration and Spec::Runner
+end
+
+require 'sgf'

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification 
+name: sgf_parser
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Guoliang Cao
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-28 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: jeweler
+  type: :development
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  name: rspec
+  type: :development
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  requirement: *id002
+description: A simple SGF parser
+email: gcao99@gmail.com
+executables: 
+- stm2dot
+- sgf
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.textile
+- TODO
+files: 
+- .irbrc
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.textile
+- Rakefile
+- TODO
+- VERSION
+- bin/sgf
+- bin/stm2dot
+- doc/sgf_state_machine.dot
+- doc/sgf_state_machine.svg
+- lib/sgf.rb
+- lib/sgf/binary_file_error.rb
+- lib/sgf/debugger.rb
+- lib/sgf/default_event_listener.rb
+- lib/sgf/model/constants.rb
+- lib/sgf/model/event_listener.rb
+- lib/sgf/model/game.rb
+- lib/sgf/model/label.rb
+- lib/sgf/model/node.rb
+- lib/sgf/model/property_handler.rb
+- lib/sgf/more/state_machine_presenter.rb
+- lib/sgf/more/stm_dot_converter.rb
+- lib/sgf/parse_error.rb
+- lib/sgf/parser.rb
+- lib/sgf/renderer.rb
+- lib/sgf/sgf_helper.rb
+- lib/sgf/sgf_state_machine.rb
+- lib/sgf/state_machine.rb
+- sgf_parser.gemspec
+- spec/fixtures/2009-11-01-1.sgf
+- spec/fixtures/2009-11-01-2.sgf
+- spec/fixtures/chinese_gb.sgf
+- spec/fixtures/chinese_utf.sgf
+- spec/fixtures/example.sgf
+- spec/fixtures/good.sgf
+- spec/fixtures/good1.sgf
+- spec/fixtures/kgs.sgf
+- spec/fixtures/test.png
+- spec/sgf/model/event_listener_spec.rb
+- spec/sgf/model/game_spec.rb
+- spec/sgf/model/node_spec.rb
+- spec/sgf/more/state_machine_presenter_spec.rb
+- spec/sgf/parse_error_spec.rb
+- spec/sgf/parser_spec.rb
+- spec/sgf/sgf_helper_spec.rb
+- spec/sgf/sgf_state_machine_spec.rb
+- spec/sgf/state_machine_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/gcao/discuz_robot
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: A SGF parser
+test_files: []
+