SgfParser 0.8.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,25 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+
+
+## Rubymine
+.idea/*

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Aldric Giacomoni
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,28 @@
+SGF: all formats (but untested with FF < 4)
+Ruby: >1.8.7 (may work with 1.8.6)
+
+Example:
+require 'sgf_parser'
+tree = SgfParser::Tree.new :filename => File
+tree = SgfParser::Tree.new :sgf_string => String
+
+All trees begin with an empty node ( @root) which allows a simple support of multiple gametrees.
+Most games will just care about, say,
+tree.root.children[0] which is the first node of the first gametree.
+
+For any node, one can summon the properties as such:
+node.properties # => returns a hash of the properties.
+A single property can be called, like the comments, for instance, like so:
+node.C # => returns the comments for this node.
+
+The library currently uses method_missing to painlessly return the data. I must admit that this is both clever coding and laziness on my part.
+
+The 'SGF Indenter', the purpose of which is to make the actual SGF file more
+human readable, is working.
+
+___
+
+TODO
+? Create a "Game" class, and if a whole set of () exists, then I have a game?
+That way maybe I can easily go to multiple games stored in a single SGF file?
+Mostly syntactic sugar, but may be worth implementing.

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "SgfParser"
+    gem.summary = %Q{A library for working with SGF files.}
+    gem.description = %Q{SGFParser is a library that parses and saves SGF (Smart Game Format) files.}
+    gem.email = "aldric@trevoke.net"
+    gem.homepage = "http://github.com/Trevoke/SGFParser"
+    gem.authors = ["Aldric Giacomoni"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+# In case I ever want to go back to cucumber.
+#begin
+#  require 'cucumber/rake/task'
+#  Cucumber::Rake::Task.new(:features)
+#
+#  task :features => :check_dependencies
+#rescue LoadError
+#  task :features do
+#    abort "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+#  end
+#end
+
+#task :default => [:spec, :features]
+
+task :default => [:spec]
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "SgfParser #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/SgfParser.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{SgfParser}
+  s.version = "0.8.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aldric Giacomoni"]
+  s.date = %q{2010-01-05}
+  s.description = %q{SGFParser is a library that parses and saves SGF (Smart Game Format) files.}
+  s.email = %q{aldric@trevoke.net}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "SgfParser.gemspec",
+     "VERSION",
+     "lib/sgf/parser/node.rb",
+     "lib/sgf/parser/properties.rb",
+     "lib/sgf/parser/tree.rb",
+     "lib/sgf/parser/tree_parse.rb",
+     "lib/sgf/sgfindent.rb",
+     "lib/sgf_parser.rb",
+     "sample_sgf/ff4_ex.sgf",
+     "sample_sgf/ff4_ex_saved.sgf",
+     "sample_sgf/redrose-tartrate.sgf",
+     "sample_usage/parsing_files.rb",
+     "spec/node_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/tree_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/Trevoke/SGFParser}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A library for working with SGF files.}
+  s.test_files = [
+    "spec/node_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/tree_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.8.0

data/lib/sgf/parser/node.rb

@@ -0,0 +1,67 @@
+module SgfParser
+
+  # Each part of the SGF Tree is a node. This holds links to the parent node,
+  # to the next node(s) in the tree, and of course, the properties of said node.
+  # Accessors : node.parent, node.children, node.properties
+  class Node
+
+    attr_accessor :parent, :children, :properties
+
+    # Creates a new node. Options 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)
+    def initialize args={}
+      @parent = args[:parent]
+      @children = []
+      add_children args[:children] if !args[:children].nil?
+      @properties = Hash.new
+      @properties.merge! args[:properties] if !args[:properties].nil?
+    end
+
+    # Adds one child or several children. Can be passed in as a comma-separated
+    # list or an array of node children. Will raise an error if one of the
+    # arguments is not of class Node.
+    def add_children *nodes
+      raise "Non-node child given!" if nodes.find { |node| node.class != Node }
+      @children.concat nodes.flatten
+    end
+
+    # Adds one or more properties to the node.
+    # Argument: a hash {'property' => 'value'}
+    def add_properties hash
+      hash.each do |key, value|
+        @properties[key] ||= ""
+        @properties[key].concat value
+      end
+    end
+
+    # Iterates over each child of the given node
+    # node.each_child { |child| puts child.properties }
+    def each_child
+      @children.each { |child| yield child }
+    end
+
+    # Compares one node's properties to another node's properties
+    def == other_node
+      @properties == other_node.properties
+    end
+
+    # Making comments easier to access.
+    def comments
+      @properties["C"]
+    end
+
+    alias :comment :comments
+
+    private
+
+    def method_missing method_name, *args
+      output = @properties[method_name.to_s.upcase]
+      super(method_name, args) if output.nil?
+      output
+    end
+
+  end
+
+end

data/lib/sgf/parser/properties.rb

@@ -0,0 +1,97 @@
+# A parser for SGF Files. Main usage: SGF::Tree.new :filename => file_name
+module SgfParser
+
+#  http://www.red-bean.com/sgf/proplist.html
+
+# Here we define SGF::Properties, so we can figure out what each property
+# is and does.
+
+  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]
+  end
+
+  # All this work for this minuscule line!
+  PROPERTIES = hash
+
+end
+

data/lib/sgf/parser/tree.rb

@@ -0,0 +1,124 @@
+module SgfParser
+
+  # This is a placeholder for the root of the gametree(s). It's an abstraction,
+  # but it allows an easy way to save, iterate over, and compare other trees.
+  # Accessors: tree.root
+  class Tree
+    include Enumerable
+
+    attr_accessor :root
+
+    # Create a new tree. Can also be used to load a tree from either a file or
+    # a string. Raises an error if both are provided.
+    # options: \n
+    # :filename => filename \n
+    # !!! OR !!! \n
+    # :sgf_string => string \n
+    def initialize args={}
+      @root = Node.new
+      @sgf = ""
+      raise ArgumentError, "Both file and string provided" if args[:filename] &&
+                                                              args[:sgf_string]
+      if !args[:filename].nil?
+        load_file args[:filename]
+      elsif !args[:sgf_string].nil?
+        load_string args[:sgf_string]
+      end
+
+    end # initialize
+
+
+    # Iterates over the tree, node by node, in preorder fashion.
+    # Does not support other types of iteration, but may in the future.
+    # tree.each { |node| puts "I am node. Hear me #{node.properties} !"}
+    def each order=:preorder, &block
+      case order
+        when :preorder
+          preorder @root, &block
+      end
+    end # each
+
+    # Compares a tree to another tree, node by node.
+    # Nodes must by the same (same properties, parents and children).
+    def == other_tree
+      one = []
+      two = []
+      each { |node| one << node }
+      other_tree.each { |node| two << node }
+      one == two
+    end # ==
+
+    # Saves the tree as an SGF file. raises an error if a filename is not given.
+    # tree.save :filename => file_name
+    def save args={}
+      raise ArgumentError, "No file name provided" if args[:filename].nil?
+      # SGF files are trees stored in pre-order traversal.
+      @sgf_string = "("
+      @root.children.each { |child| write_node child }
+      # write_node @root
+      @sgf_string << ")"
+
+      File.open(args[:filename], 'w') { |f| f << @sgf_string }
+    end #save
+
+    private
+
+    # Adds a stringified node to the variable @sgf_string - for saving purposes. 
+    def write_node node=@root
+      @sgf_string << ";"
+      unless node.properties.empty?
+        properties = ""
+        node.properties.each do |k, v|
+          v_escaped = v.gsub("]", "\\]")
+          properties += "#{k.to_s}[#{v_escaped}]"
+        end
+        @sgf_string << "#{properties}"
+      end
+
+      case node.children.size
+        when 0
+          @sgf_string << ")"
+        when 1
+          write_node node.children[0]
+        else
+          node.each_child do |child|
+            @sgf_string << "("
+            write_node child
+          end
+      end
+    end
+
+    # Used to load and parse a string if a string was given.
+    def load_string string
+      @sgf = string
+      parse unless @sgf.empty?
+    end # load_string
+
+    # Used to load and parse a file if a file was given.
+    def load_file filename
+      @sgf = ""
+      File.open(filename, 'r') { |f| @sgf = f.read }
+      parse unless @sgf.empty?
+    end # load_file
+
+    # Traverse the tree in preorder fashion, starting with the @root node if
+    # no node is given, and activating the passed block on each.
+    def preorder node=@root, &block
+      # stop processing if the block returns false
+      if yield node then
+        node.each_child do |child|
+          preorder(child, &block)
+        end
+      end
+    end # preorder      
+
+    def method_missing method_name, *args
+      output = @root.children[0].properties[method_name]
+      super(method_name, args) if output.nil?
+      output
+    end # method_missing    
+
+  end
+
+end
+