nachof-zheng 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Nacho Facello
+
+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,41 @@
+= Zheng
+
+Zheng is a small utility to manage go ratings.
+
+Zheng is based on the method used by the European Go Federation (described in http://gemma.ujf.cas.cz/~cieply/GO/gor.html).
+
+== About the name
+The name Zheng comes from the chinese 证 (zhèng), which, according to Sensei's Library (http://senseis.xmp.net/?ChineseGoTerms), means a rank certificate or diploma.
+
+== Dependencies
+You will need rubygems installed. Also, you will need the following gems:
+* sequel
+* sqlite3
+* shellwords
+
+== Usage
+
+=== Adding players
+To create a player, do
+  bin/zheng player add "Player Name" 1k
+You can also use the numeric rating for the initial rating:
+  bin/zheng player add "Player Name" 2000
+Given that 1k is 2000 points in the rating system, both commands are equivalent.
+
+To see a list of players:
+  bin/zheng player list
+
+=== Adding a game
+To add a game, do
+  bin/zheng game add "First Player" "Second Player" winner
+where _winner_ is either left, right, first, or second. Left and first are the same, and right and second are the same, too.
+
+When a game is added the rank of its participants is immediately updated to reflect the result.
+
+=== External players
+You can also add "external players". External players are there to allow to record games played against other people, outside the system you're managing. The idea of this is to keep a certain correspondence to global ranks, and avoid too much drifting, either by deflation or inflation. To add an external player, do
+  bin/zheng player add_external "Player Name" 1d
+
+External players do not normally show up on player listings, and their rank is not changed by games. If you want to see a list including also external players, use
+  bin/zheng player list all
+

data/bin/zheng

@@ -0,0 +1,11 @@
+#!/usr/bin/ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'config', 'init'))
+
+include Zheng
+
+if ARGV.size > 0
+  Actions::call(*ARGV)
+else
+  Actions::script $stdin
+end

data/lib/zheng.rb

@@ -0,0 +1,6 @@
+require File.join(File.dirname(__FILE__), 'zheng', 'parameters')
+require File.join(File.dirname(__FILE__), 'zheng', 'util')
+require File.join(File.dirname(__FILE__), 'zheng', 'rating')
+require File.join(File.dirname(__FILE__), 'zheng', 'player')
+require File.join(File.dirname(__FILE__), 'zheng', 'game')
+require File.join(File.dirname(__FILE__), 'zheng', 'actions')

data/lib/zheng/actions.rb

@@ -0,0 +1,27 @@
+module Zheng
+  module Actions
+    module_function
+    def call(mod, action, *params)
+      "Actions::#{mod.camelize}".constantize.send(action.to_sym, *params)
+    rescue NameError
+      raise NoActionFound.new("#{mod} #{action} (#{$!})")
+    end
+
+    def script text
+      text.each_line do |l|
+        begin
+          call *Shellwords.shellwords(l) unless l.strip.empty? || l.strip[0,1] == '#'
+        rescue
+          Zheng::output("An error occured: #{$!}")
+        end
+      end
+    end
+
+    class NoActionFound < Exception; end
+  end
+
+end
+
+require File.join(File.dirname(__FILE__), 'actions', 'player')
+require File.join(File.dirname(__FILE__), 'actions', 'game')
+require File.join(File.dirname(__FILE__), 'actions', 'database')

data/lib/zheng/actions/database.rb

@@ -0,0 +1,11 @@
+module Zheng
+  module Actions
+    module Database
+      module_function
+      def clear
+        Zheng::Player.delete
+        Zheng::Game.delete
+      end
+    end
+  end
+end

data/lib/zheng/actions/game.rb

@@ -0,0 +1,25 @@
+module Zheng
+  module Actions
+    module Game
+      module_function
+      def add lname, rname, winner
+        left, right = [ lname, rname ].map { |n| Zheng::Player.named(n) }
+        game = Zheng::Game.create :left => left, :right => right, :winner => winner_sym(winner)
+        unless left.external?
+          left.rating = left.rating + game.rating_change_for(:left)
+          left.save
+        end
+        unless right.external?
+          right.rating = right.rating + game.rating_change_for(:right)
+          right.save
+        end
+      end
+
+      def winner_sym winner
+        return :left if winner == "first"
+        return :right if winner == "second"
+        return winner.to_sym
+      end
+    end
+  end
+end

data/lib/zheng/actions/player.rb

@@ -0,0 +1,42 @@
+module Zheng
+  module Actions
+    module Player
+      module_function
+
+      def add(name, rank)
+        if Zheng::Rating.is_rank? rank
+          Zheng::Player.create(:name => name, :rank => rank)
+        else
+          Zheng::Player.create(:name => name, :rating => rank.to_i)
+        end
+      end
+
+      def add_external(name, rank)
+        p = add(name, rank)
+        p.set_external!
+        p.save
+      end
+
+      def list what="local"
+        what_to_list = (what == "all") ? :all : :local
+        Zheng::Player.list(what_to_list).each do |p|
+          Zheng::output(sprintf "%-20.20s %s (%s)", p.name, p.rank, p.rating)
+        end
+      end
+
+      def delete name
+        Zheng::Player.named(name).destroy
+      end
+
+      def set_rating name, rank
+        p = Zheng::Player.named(name)
+        if Zheng::Rating.is_rank? rank
+          p.rank = rank
+        else
+          p.rating = rank.to_i
+        end
+        p.save
+      end
+    end
+  end
+end

data/lib/zheng/game.rb

@@ -0,0 +1,35 @@
+module Zheng
+  class Game < Sequel::Model
+    set_schema do
+      primary_key :id
+      foreign_key :left_id, :players
+      foreign_key :right_id, :players
+      text :winner, :null => false
+    end
+
+    include Util
+
+    belongs_to :left, :class => :Player
+    belongs_to :right, :class => :Player
+
+    sequel_accessor :right_id, :left_id
+
+    def winner
+      @values[:winner].to_sym
+    end
+    def winner= v
+      @values[:winner] = v.to_s
+    end
+
+    def rating_change_for which_player
+      which_opponent = (which_player == :left) ? :right : :left
+      player, opponent = [which_player, which_opponent].map { |p| send(p) }
+      return Parameters::Con(player.rating) * (result(which_player) - Parameters::expected(player.rating, opponent.rating))
+    end
+
+    def result which_player
+      (which_player == winner) ? 1 : 0
+    end
+  end
+end
+

data/lib/zheng/parameters.rb

@@ -0,0 +1,29 @@
+module Zheng
+  module Parameters
+    module_function
+    # These values are taken from the European Go Rating. See http://gemma.ujf.cas.cz/~cieply/GO/gor.html
+    E = 0.014
+    def A rating
+      return 70 if rating >= 2700
+      return rating * (-1.0/20) + (205)
+    end
+    def Con rating
+      return 10 if rating > 2700
+      return 116 if rating < 100
+      parts = [ { :from => 100, :to => 200, :p => -6.0/100, :d => 122 },
+                { :from => 200, :to => 1300, :p => -5.0/100, :d => 120 },
+                { :from => 1300, :to => 2000, :p => -4.0/100, :d => 107 },
+                { :from => 2000, :to => 2400, :p => -3.0/100, :d => 87 },
+                { :from => 2400, :to => 2600, :p => -2.0/100, :d => 63 },
+                { :from => 2600, :to => 2700, :p => -1.0/100, :d => 37 } ]
+      parts.each do |f|
+        return f[:p] * rating + f[:d] if rating >= f[:from] && rating <= f[:to]
+      end
+    end
+
+    def expected ratingA, ratingB
+      return (1 - E) - expected(ratingB, ratingA) if ratingA > ratingB
+      return 1.0 / (Math::E ** ((ratingB - ratingA) / A(ratingA)) + 1)
+    end
+  end
+end

data/lib/zheng/player.rb

@@ -0,0 +1,38 @@
+module Zheng
+  class Player < Sequel::Model
+    set_schema do
+      primary_key :id
+      text :name, :null => false, :unique => true
+      integer :rating, :null => false
+      boolean :external, :default => false
+    end
+
+    include Util
+
+    sequel_accessor :name, :rating
+
+    def rank
+      Rating.new(rating).rank
+    end
+    def rank= rank
+      self.rating = Rating.new(rank).to_i
+    end
+
+    def external?
+      return @values[:external]
+    end
+    def set_external!
+      @values[:external] = true
+    end
+
+    def self.named name
+      raise "Can't find player #{name}" if (found = self[:name => name]).nil?
+      found
+    end
+
+    def self.list what=:local
+      what_to_order = (what == :all) ? self : filter(:external => false)
+      what_to_order.reverse_order(:rating)
+    end
+  end
+end

data/lib/zheng/rating.rb

@@ -0,0 +1,42 @@
+module Zheng
+  class Rating
+    def initialize(rating)
+      @rating = rating.respond_to?(:match) ? from_rank(rating) : rating.to_i
+    end
+
+    def from_rank(rank)
+      parts = rank.match(/(\d+)(k|d)/)
+      return 2000 + (parts[1].to_i * 100) if parts[2] == 'd'
+      return 2100 - (parts[1].to_i * 100) if parts[2] == 'k'
+      raise "Invalid rank"
+    end
+
+    def to_i
+      @rating
+    end
+
+    def rank
+      level = (@rating / 100.0).round
+      return (level - 20).to_s + 'd' if level > 20
+      return (21 - level).to_s + 'k'
+    end
+
+    def + other
+      self.class.new(@rating + other.to_i)
+    end
+
+    def == other
+      @rating == other.to_i
+    end
+
+    def eql? other
+      @rating == other.to_i
+    end
+
+    def self.is_rank? string
+      return false unless string.respond_to? :match
+      return false unless string.match /\d+(k|d)/
+      return true
+    end
+  end
+end

data/lib/zheng/util.rb

@@ -0,0 +1,30 @@
+module Zheng
+  module Util
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def sequel_accessor *params
+        params.each do |method|
+          class_eval <<-end_eval
+            def #{method.to_s}
+              @values[:#{method.to_s}]
+            end
+            def #{method.to_s}= v
+              @values[:#{method.to_s}] = v
+            end
+          end_eval
+        end
+      end
+    end
+
+  end
+
+  module_function
+  # I put it here so I can easily silence it for tests
+  def output text
+    puts text
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: nachof-zheng
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Nacho Facello
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-09 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sequel
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.8.0
+    version: 
+description: 
+email: nacho@nucleartesuji.com
+executables: 
+- zheng
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/zheng/actions/database.rb
+- lib/zheng/actions/game.rb
+- lib/zheng/actions/player.rb
+- lib/zheng/actions.rb
+- lib/zheng/game.rb
+- lib/zheng/parameters.rb
+- lib/zheng/player.rb
+- lib/zheng/rating.rb
+- lib/zheng/util.rb
+- lib/zheng.rb
+- README.rdoc
+- LICENSE
+has_rdoc: false
+homepage: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  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: A go ratings calculator, based on the method published by the European Go Federation
+test_files: []
+