theoros-rubysgf 0.0.2

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Adam Prescott <disaffect@gmail.com>
+
+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/lib/rubysgf.rb

@@ -0,0 +1,76 @@
+#--
+# Copyright (c) 2008 Adam Prescott
+# licensed as specified under LICENSE.txt
+#++
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "strscan"
+require "sgf/errors"
+require "sgf/coordinates"
+require "sgf/compressed_list"
+require "sgf/property"
+require "sgf/node"
+require "sgf/record"
+
+module RubySGF
+  VERSION = "0.0.2"
+
+  module SGF # Go-specific under FF[4]
+    
+    ALL_PROPERTY_NAMES = %w{ B KO MN W AB AE AW PL C DM GB GW HO N UC V BM DO IT TE AR CR DD LB LN MA SL SQ TR AP CA FF GM ST SZ AN BR BT CP DT EV GN GC ON OT PB PC PW RE RO RU SO TM US WR WT BL OB OW WL FG PM VW HA KM TB TW }
+  
+    # properties which have values which are coordinates and implemented by this program
+    COORDINATE_PROPERTIES = %w{ B W AB AW AE CR MA SQ TR TW TB }
+  
+    # the properties going to be implemented by this program
+    PROPERTY_NAMES_HASH = { 
+      :black_move => "B",
+      :white_move => "W",
+      :black_stones => "AB",
+      :white_stones => "AW",
+      :neutral_points => "AE",
+      :comment => "C",
+      :node_name => "N",
+      :circled_points => "CR",
+      :label => "LB",
+      :marked_x => "MA",
+      :squared_points => "SQ",
+      :triangled_points => "TR",
+      :application => "AP",
+      :character_set => "CA",
+      :file_format => "FF",
+      :game_type => "GM",
+      :board_size => "SZ",
+      :annotator => "AN",
+      :black_rank => "BR",
+      :copyright_info => "CP",
+      :game_date => "DT",
+      :game_name => "GN",
+      :overtime => "OT",
+      :black_player => "PB",
+      :game_location => "PC",
+      :white_player => "PW",
+      :game_result => "RE",
+      :ruleset => "RU",
+      :source => "SO",
+      :time_limits => "TM",
+      :white_rank => "WR",
+      :black_time_left => "BL",
+      :black_overtime => "OB",
+      :white_time_left => "WL",
+      :white_overtime => "OW",
+      :handicap => "HA",
+      :komi => "KM",
+      :white_territory => "TW",
+      :black_territory => "TB",
+      :markup_style => "ST"
+    }
+  
+    # implemented by this program
+    PROPERTY_NAMES = PROPERTY_NAMES_HASH.values
+    
+    NOT_IMPLEMENTED_PROPERTY_NAMES = ALL_PROPERTY_NAMES - PROPERTY_NAMES
+  end # SGF
+end # RSGF

data/lib/sgf/compressed_list.rb

@@ -0,0 +1,30 @@
+#--
+# Copyright (c) 2008 Adam Prescott
+# licensed as specified under LICENSE.txt
+#++
+
+module RubySGF
+  module SGF
+    class CompressedList
+      attr_reader :ulx, :uly, :lrx, :lry
+      def initialize(upper_left_x, upper_left_y, lower_right_x, lower_right_y)
+        @ulx, @uly, @lrx, @lry = upper_left_x, upper_left_y, lower_right_x, lower_right_y
+      end
+      
+      # expand compressed list to array
+      def to_a
+        smallx, bigx = [ulx, lrx].sort.map { |i| Coordinates::HORIZONTAL.index(i) }
+        xgap = bigx - smallx
+        smally, bigy = [uly, lry].sort.map { |i| Coordinates::VERTICAL.index(i) }
+        ygap = bigy - smally
+        coord_list = []
+        Coordinates::VERTICAL[smally..bigy].each do |y|
+          Coordinates::HORIZONTAL[smallx..bigx].each do |x|
+            coord_list << [x,y]
+          end
+        end
+        coord_list.sort
+      end
+    end # compressedlist
+  end # sgf
+end # rsgf

data/lib/sgf/coordinates.rb

@@ -0,0 +1,74 @@
+#--
+# Copyright (c) 2008 Adam Prescott
+# licensed as specified under LICENSE.txt
+#++
+
+module RubySGF
+  module SGF
+    class Coordinates
+      VERTICAL = HORIZONTAL = [*"a".."z"] + [*"A".."Z"]
+  
+      attr_reader :x, :y
+      def initialize(x, y)
+        @x = x
+        @y = y
+      end
+      
+      def ==(second_coordinates)
+        @x == second_coordinates.x && @y == second_coordinates.y
+      end
+      
+      def neighbours(size)
+        [up, right, down, left].compact.map do |c|
+          c.inside?(size) ? c : nil
+        end
+      end
+      
+      def inside?(size)
+        vert = VERTICAL[0,size]
+        horiz = HORIZONTAL[0,size]
+        horiz.include?(@x) && vert.include?(@y)
+      end
+      
+      def outside?(size)
+        !inside?(size)
+      end
+      
+      def up
+        idx = VERTICAL.index(y) - 1
+        return nil unless idx >= 0
+        new_y = VERTICAL[idx]
+        return nil unless new_y
+        Coordinates.new(x, new_y)
+      end
+      
+      def right
+        idx = HORIZONTAL.index(x) + 1
+        return nil unless idx >= 0
+        new_x = HORIZONTAL[idx]
+        return nil unless new_x
+        Coordinates.new(new_x, y)
+      end
+      
+      def down
+        idx = VERTICAL.index(y) + 1
+        return nil unless idx >= 0
+        new_y = VERTICAL[idx]
+        return nil unless new_y
+        Coordinates.new(x, new_y)
+      end
+      
+      def left
+        idx = HORIZONTAL.index(x) - 1
+        return nil unless idx >= 0
+        new_x = HORIZONTAL[idx]
+        return nil unless new_x
+        Coordinates.new(new_x, y)
+      end
+      
+      def to_s
+        @x + @y
+      end
+    end # coordinates
+  end # SGF
+end # RSGF

data/lib/sgf/errors.rb

@@ -0,0 +1,14 @@
+#--
+# Copyright (c) 2008 Adam Prescott
+# licensed as specified under LICENSE.txt
+#++
+
+module RubySGF
+  module SGF
+    class SGFError < StandardError
+    end
+    
+    class PropertyError < SGFError
+    end
+  end # SGF
+end # RSGF

data/lib/sgf/node.rb

@@ -0,0 +1,68 @@
+#--
+# Copyright (c) 2008 Adam Prescott
+# licensed as specified under LICENSE.txt
+#++
+
+module RubySGF
+  module SGF
+    #--
+    # this class is partially inspired by code written by
+    # Stefan Rusterholz, stefan.rusterholz <AT> gmail <DOT> com
+    #++
+    class Node
+      
+      attr_reader :parent, :children, :number
+      attr_accessor :properties
+      
+      def initialize(parent, properties = [])
+        @parent = parent
+        @properties = properties
+        @children = []
+        
+        @parent << self if parent
+        
+        if parent
+          @number = parent.number + 1
+        else
+          @number = 0
+        end
+      end
+      
+      def prev
+        @parent
+      end
+      
+      def next
+        @children[0]
+      end
+          
+      def [](index)
+        @children[index]
+      end
+      
+      def <<(node)
+        @children << node
+      end
+      
+      def leaf?
+        @children.empty?
+      end
+      
+      def root?
+        @parent.nil?
+      end
+      
+      def to_s
+        " "*@number << @number.to_s
+      end
+      
+      def write_tree(string="")
+        string << self.to_s << "\n"
+        @children.each do |child|
+          child.write_tree(string)
+        end
+        string
+      end # write_tree
+    end # class
+  end # sgf
+end # rsgf

data/lib/sgf/property.rb

@@ -0,0 +1,102 @@
+#--
+# Copyright (c) 2008 Adam Prescott
+# licensed as specified under LICENSE.txt
+#++
+
+module RubySGF
+  module SGF
+    class Property
+      
+      DEFAULTS = {"AP" => "rGo:0.1a", "GM" => "1", "FF" => "4", "SZ" => "19", "PW" => "White", "PB" => "Black"}
+  
+      attr_reader :name, :value
+  
+      # /(PN\[((?:[^\]\\]+|\\[\]\[]?)*?)\])/ --> /(PN\[((?:[^\]\\]+|\\[\]\[]?)*?)\])+/
+      # allows lists to be taken into account [aa][ev][gg]
+      # returns PN[everything here including escaped \] like this]
+      MATCH = /(\[((?:[^\]\\]+|\\[\]\[]?)*?)\])/
+      MATCH_MANY = /(\[((?:[^\]\\]+|\\[\]\[]?)*?)\])+/
+  
+  
+      def initialize(name, value)
+        @name = name
+        @value = value
+      end
+      
+      def human_name
+        Property.human_name_of(@name)
+      end
+  
+      class << self
+  
+        def create_many_from_raw(text, properties)
+          properties.map! do |pn|
+            Property.create_from_raw(text,pn)
+          end
+        end
+        
+        def create_from_raw(text, property_name)
+          prop_value = Property.parse_sgf(text, property_name) # Array, may be size 1 or more
+          prop_value.map! do |v|
+            if COORDINATE_PROPERTIES.include? property_name
+              Coordinates.new(v[0,1], v[1,1])
+            elsif property_name == "LB"
+              v = v.split(":")
+              v[0] = Coordinates.new(v[0][0,1], v[0][1,1])
+              v
+            else
+              v
+            end
+          end
+          new(property_name, prop_value)
+        end
+          
+        # take a text of properties (NAME[VALUE], or otherwise) and return the value(s)
+        def parse_sgf(input, property_name)
+          $stderr << "invalid property detected (will be ignored): #{property_name} -- \"#{input}\"\n" unless Property.valid?(property_name)
+          match_many = MATCH_MANY.source
+          match = MATCH.source
+          output = ""
+          case property_name
+          when "C"
+            output = input[/#{property_name}#{match}/m][2..-2]
+          when "GN"
+            output = input[/#{property_name}#{match}/m][3..-2]
+          else
+            output = input.gsub("\n","")[/#{property_name}#{match_many}/][2..-1].scan(/[^\[\]]+/)
+          end
+          [*output]
+        end
+        
+        def valid?(name)
+          ALL_PROPERTY_NAMES.include?(name)
+        end
+        
+        def compressed_list?(val)
+          val =~ /^[a-z][a-z]\:[a-z][a-z]$/i
+        end
+        
+        def expand_list(val)
+          ulx, uly, lrx, lry = val.scan(/^([a-z])([a-z])\:([a-z])([a-z])$/i).flatten
+          CompressedList.new(ulx, uly, lrx, lry).to_a
+        end
+        
+        def can_be_nil?(property_name)
+          ["W","B"].include?(property_name)
+        end
+      end
+  
+      private
+  
+      class << self
+        def human_name_of(name)
+          PROPERTY_NAMES_HASH.invert[name]
+        end
+        
+        def sgf_name_of(sym)
+          PROPERTY_NAMES_HASH[sym]
+        end
+      end
+    end
+  end
+end

data/lib/sgf/record.rb

@@ -0,0 +1,66 @@
+#--
+# Copyright (c) 2008 Adam Prescott
+# licensed as specified under LICENSE.txt
+#++
+
+module RubySGF
+  module SGF
+    class Record
+      attr_reader :data, :root, :info
+      
+      def initialize(data = nil)
+        @data = data
+        if data
+          @root = Record.create_tree(@data)
+        else
+          n = Node.new(nil)
+          n.properties = Property::DEFAULTS.map do |name, value|
+            Property.new(name, [value])
+          end
+          @root = n
+        end
+      end
+      
+      def to_s
+        @root.write_tree
+      end
+      
+      private
+      
+      class << self
+        def create_tree(str)
+          str = StringScanner.new(str)
+          root_node = node = nil
+          old_nodes = []
+          until str.eos?
+            case s = str.getch
+            when "("
+              old_nodes << node
+              node = Node.new(node)
+              root_node = node if node.root?
+            when ";"
+              # pass along all of the properties of the current node to Node for creation
+              # we ignore ; ( ) chars inside property values
+              node_text = str.scan(/[A-Z]+\[.*?\]\s*[;\(\)]/m).strip[0..-2]
+              # look for all property names 
+              property_names = node_text.scan(/((?:[A-Z]+)(?:[^\\]|))\[/).flatten
+              $stderr << "Error around \"#{str.matched}\": multiple properties of the same type -- all but the first instance will be ignored\n" if property_names.uniq!
+              properties = Property.create_many_from_raw(node_text, property_names)
+              if node.properties.empty? # every node must have a property
+                node.properties = properties
+              else
+                node = Node.new(node, properties)
+              end
+              str.pos -= 1 # move back before the ; or ( or )
+            when ")"
+              node = old_nodes.pop
+            else
+              next
+            end # case
+          end # until
+          root_node
+        end # create_tree
+      end # singleton
+    end # record
+  end # SGF
+end # RSGF

data/rubysgf.gemspec

@@ -0,0 +1,25 @@
+Gem::Specification.new do |s|
+  s.name     = "rubysgf"
+  s.version  = "0.0.2"
+  s.date     = "2008-08-22"
+  s.summary  = "SGF file reader for Ruby"
+  s.email    = "disaffect@gmail.com"
+  s.homepage = "http://github.com/theoros/rubysgf"
+  s.description = "A Ruby library to read SGF files and create objects out of them."
+  s.required_ruby_version = "~> 1.8.6"
+  s.has_rdoc = false
+  s.authors  = ["Adam Prescott"]
+  s.files    = ["LICENSE.txt", 
+		"rubysgf.gemspec", 
+		"lib/rubysgf.rb",
+		"lib/sgf/compressed_list.rb",
+		"lib/sgf/coordinates.rb",
+		"lib/sgf/errors.rb",
+		"lib/sgf/node.rb",
+		"lib/sgf/property.rb",
+		"lib/sgf/record.rb",
+		]
+  s.rdoc_options = []#["--main", "README.txt"]
+  s.extra_rdoc_files = []#["History.txt", "Manifest.txt", "README.txt"]
+  #s.add_dependency("mime-types", ["> 0.0.0"])
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: theoros-rubysgf
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Adam Prescott
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-22 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A Ruby library to read SGF files and create objects out of them.
+email: disaffect@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE.txt
+- rubysgf.gemspec
+- lib/rubysgf.rb
+- lib/sgf/compressed_list.rb
+- lib/sgf/coordinates.rb
+- lib/sgf/errors.rb
+- lib/sgf/node.rb
+- lib/sgf/property.rb
+- lib/sgf/record.rb
+has_rdoc: false
+homepage: http://github.com/theoros/rubysgf
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ~>
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: SGF file reader for Ruby
+test_files: []
+