olympic 0.0.1 → 0.0.2

data/lib/olympic/rating.rb

@@ -0,0 +1,16 @@
+require 'olympic/rating/base'
+require 'olympic/rating/glicko'
+
+module Olympic
+  module Rating
+
+    RATINGS = {
+      glicko: Glicko
+    }
+
+    def self.for(name)
+      RATINGS.fetch(name)
+    end
+
+  end
+end

data/lib/olympic/rating/base.rb

@@ -0,0 +1,26 @@
+module Olympic
+  module Rating
+    # The base rating.  A rating is used to describe the performance
+    # of a unit, e.g. one team.  This is just an abstraction of the
+    # rating system, and as such, doesn't actually implement the API.
+    class Base
+
+      # Returns a hash of the fields that are required on a
+      # {Olympic::Team} to make it compatible with the rating system.
+      # The base API requires no fields.  However, if it were to
+      # require a `:rating` decimal field, it would have a value of
+      # something like this:
+      #
+      #     { rating: [:decimal, { null: false, default: 100.2 }] }
+      #
+      # The key is the name of the field, the value are options that
+      # are passed as options to the SQL column.
+      #
+      # @return [Hash{Symbol => Array<(Symbol, Hash)>}]
+      def self.required_fields
+        {}
+      end
+
+    end
+  end
+end

data/lib/olympic/rating/glicko.rb

@@ -0,0 +1,95 @@
+require "memoist"
+require "forwardable"
+require "olympic/rating/glicko/formula"
+
+module Olympic
+
+  # note:
+  #   Match#rating
+  #   Match#outcome
+  #   Match#derivation
+  #
+  module Rating
+    # The Glicko rating system.  This is Glicko, not Glicko2.
+    #
+    # @see http://www.glicko.net/glicko/glicko.pdf
+    class Glicko < Base
+
+      extend Memoist
+      extend Forwardable
+      def_delegators :@team, :rating=, :derivation=
+
+      # (see Base.required_fields)
+      def self.required_fields
+        {
+          rating:     [:float, { null: false,
+                                 default: Formula::DEFAULT_RATING }],
+          derivation: [:float, { null: false,
+                                 default: Formula::DEFAULT_RATING_DERIVATION }]
+        }
+      end
+
+      def initialize(team)
+        @team = team
+      end
+
+      # Updates the rating with the given match information.  Matches
+      # should be an array of hashes that contain information about
+      # those matches.
+      #
+      # @param matches [Array<Olympic::Match>]
+      # @return [void]
+      def update(matches)
+        standardized = standardize_matches(matches)
+        Formula.new(self, standardized).call
+      end
+
+      def rating
+        @team.rating ||= 1500
+      end
+
+      def derivation
+        case
+        when unrated?         then 350
+        when time_passed == 0 then @team.derivation
+        else
+          [
+            30,
+            Math.sqrt(@team.derivation ** 2 +
+              CERTAINTY_DECAY * time_passed),
+            350
+          ].sort[1]
+        end
+      end
+      memoize :derivation
+
+      def time_passed
+        # TODO
+        0
+      end
+
+      def unrated?
+        @team.rating == nil && @team.derivation == nil
+      end
+
+      private
+
+      # @param matches [Array<Olympic::Match>]
+      # @return [Array<Hash>]
+      def standardize_matches(matches)
+        matches.map do |match|
+          raise Rating::Error, "Too many/few incoming sources" unless
+            match.incoming.size == 2
+          other = match.participants.find { |team| team != @team }
+          raise Rating::Error, "Could not find combatant" unless other
+          other = Glicko.new(other)
+          {
+            rating: other.rating,
+            derivation: other.derivation,
+            outcome: if match.winner == @team then 1 else 0 end
+          }
+        end
+      end
+    end
+  end
+end

data/lib/olympic/rating/glicko/formula.rb

@@ -0,0 +1,119 @@
+require 'memoist'
+
+module Olympic
+  module Rating
+    class Glicko < Base
+      class Formula
+
+        extend Memoist
+
+        # The default rating.  Glicko states to use 1500 as the
+        # default.
+        DEFAULT_RATING = 1500
+
+        # The default RD.  Glicko states to use 350 as the default.
+        DEFAULT_RATING_DERIVATION = 350
+
+        # This is the "certainty decay," or the constant value that
+        # is used in Step 1 of the Glicko rating system.  It denotes
+        # the decay of certainty of a player's rating over a given
+        # time (see {Glicko} for a definition of time).  The default
+        # chosen here expects a typical RD of 50, with 10 time units
+        # before a decay to 350.  The formula would be (in LaTeX):
+        #
+        #   c = \sqrt{\frac{350^2-50^2}{10}}
+        #
+        # However, in order to optimize operations, this is c^2.  So
+        # the actual value of this would be:
+        #
+        #   c = \frac{350^2-50^2}{10}
+        CERTAINTY_DECAY = 12_000
+
+        Q  = Math.log2(10).fdiv(400)
+        Q2 = Q ** 2
+
+        def initialize(unit, matches)
+          @unit = unit
+          @matches = matches
+        end
+
+        def call
+          flush_cache
+          @unit.rating = new_rating
+          @unit.derivation = new_derivation
+        end
+
+        # This returns the current rating derivation of the unit.  It
+        # clamps the rating derivation to between 30 and 350.  The
+        # Glicko system states that it must be less than or equal to
+        # 350, but later recommends not letting the rating derivation
+        # drop below 30.
+        #
+        # @return [Numeric]
+        def derivation
+          if @unit.unrated?
+            350
+          elsif @unit.time_passed == 0
+            @unit.derivation
+          else
+            a = [
+              30,
+              Math.sqrt((@unit.derivation) ** 2 + CERTAINTY_DECAY * @unit.time_passed),
+              350
+            ].sort[1]
+          end
+        end
+        memoize :derivation
+
+        private
+
+        def new_rating
+          @unit.rating +
+            Q.fdiv(1.0.fdiv(derivation ** 2) + 1.0.fdiv(delta)) * summation
+        end
+        memoize :new_rating
+
+        def new_derivation
+          Math.sqrt(1.0.fdiv(
+            1.0.fdiv(derivation ** 2) + 1.0.fdiv(delta)))
+        end
+        memoize :new_derivation
+
+        def summation
+          @matches.inject(0) do |memo, value|
+            e = epsilon(value[:rating], value[:derivation])
+            g = gamma(value[:derivation])
+            memo + g * (value[:outcome] - e)
+          end
+        end
+        memoize :summation
+
+        def delta
+          1.0.fdiv(Q2 * delta_summation)
+        end
+        memoize :delta
+
+        def delta_summation
+          @matches.inject(0) do |memo, value|
+            e = epsilon(value[:rating], value[:derivation])
+            g = gamma(value[:derivation])
+            memo + (g ** 2) * e * (1 - e)
+          end
+        end
+        memoize :delta_summation
+
+        def gamma(derivation)
+          1.0.fdiv Math.sqrt(1 + (3 * Q2 * (derivation ** 2)).fdiv(Math::PI ** 2))
+        end
+        memoize :gamma
+
+        def epsilon(rating, derivation)
+          1.0.fdiv(1 + 10 **
+            (gamma(derivation) * (@unit.rating - rating)).fdiv(-400))
+        end
+        memoize :epsilon
+
+      end
+    end
+  end
+end

data/lib/olympic/settings.rb

@@ -0,0 +1,80 @@
+require 'forwardable'
+require 'olympic/settings/class_methods'
+
+module Olympic
+  class Settings
+
+    extend ClassMethods
+    extend Forwardable
+
+    def_delegators :@settings, :fetch
+
+    DEFAULT_SETTINGS = {
+      match_class: "Match",
+      match_primary_key: :id,
+      match_tournament_key: :tournament_id,
+      match_foreign_key: :match_id,
+      match_winner_key: :winner_id,
+      match_join_key: :match_id,
+      team_class: "Team",
+      team_primary_key:  :id,
+      team_tournament_join: :teams_tournaments,
+      team_join_key: :team_id,
+      tournament_class: "Tournament",
+      tournament_primary_key: :id,
+      tournament_root_key: :root_id,
+      tournament_join_key: :tournament_id,
+      source_class: "Source",
+      source_primary_key: :id,
+      source_match_key: :match_id,
+      source_source_key: :source_id,
+      source_source_type: :source_type,
+      rating: :glicko
+    }
+
+    def initialize(settings = {})
+      @settings = DEFAULT_SETTINGS.clone.merge(settings)
+      @klass = {}
+    end
+
+    def build
+      yield self
+      self
+    end
+
+    def []=(key, value)
+      @klass = {}
+      @settings[key.to_s.to_sym] = value
+    end
+
+    def [](key)
+      @settings.fetch(key.to_s.to_sym)
+    end
+
+    def class_for(name)
+      @klass.fetch(name) do
+        @klass[name] = fetch(:"#{name}_class").constantize
+      end
+    end
+
+    def rating_system
+      Rating.for(rating)
+    end
+
+    def method_missing(method, *args, &block)
+      return super if args.length > 1 || block_given?
+
+      method = method.to_s
+      case method
+      when /\?\z/, /\!\z/
+        super
+      when /\A(.*)\=\z/
+        super unless args.length == 1
+        self[$+] = args[0]
+      else
+        super unless args.length == 0
+        self[method]
+      end
+    end
+  end
+end

data/lib/olympic/settings/class_methods.rb

@@ -0,0 +1,19 @@
+require 'forwardable'
+
+module Olympic
+  class Settings
+    module ClassMethods
+
+      extend Forwardable
+
+      def_delegators :settings, :[], :[]=, :class_for, :fetch,
+        :rating_system, :method_missing
+      def_delegator :settings, :build, :configure
+
+      def settings
+        @_settings ||= Settings.new
+      end
+
+    end
+  end
+end

data/lib/olympic/source.rb

@@ -0,0 +1,19 @@
+module Olympic
+  module Source
+
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :match,
+        class_name: Olympic::Settings[:match_class],
+        foreign_key: Olympic::Settings[:source_match_key],
+        primary_key: Olympic::Settings[:match_primary_key]
+      belongs_to :source,
+        polymorphic: true,
+        foreign_type: Olympic::Settings[:source_source_type],
+        foreign_key: Olympic::Settings[:source_source_key],
+        primary_key: Olympic::Settings[:source_primary_key]
+    end
+
+  end
+end

data/lib/olympic/team.rb

@@ -0,0 +1,23 @@
+module Olympic
+  module Team
+
+    extend ActiveSupport::Concern
+
+    included do
+      has_and_belongs_to_many :tournaments,
+        class_name: Olympic::Settings[:tournament_class],
+        join_table: Olympic::Settings[:team_tournament_join],
+        foreign_key: Olympic::Settings[:team_join_key],
+        association_foreign_key: Olympic::Settings[:tournament_join_key]
+      has_many :sources,
+        class_name:   Olympic::Settings[:source_class],
+        foreign_key:  Olympic::Settings[:source_source_key],
+        foreign_type: Olympic::Settings[:source_source_type],
+        primary_key:  Olympic::Settings[:team_primary_key],
+        as: :sources
+      has_many :matches,
+        class_name:   Olympic::Settings[:match_class],
+        through:      :sources
+    end
+  end
+end

data/lib/olympic/tournament.rb

@@ -0,0 +1,31 @@
+module Olympic
+  module Tournament
+
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :matches,
+        class_name: Olympic::Settings[:match_class],
+        foreign_key: Olympic::Settings[:match_tournament_key],
+        primary_key: Olympic::Settings[:tournament_primary_key]
+      belongs_to :root,
+        class_name: Olympic::Settings[:match_class],
+        foreign_key: Olympic::Settings[:tournament_root_key],
+        primary_key: Olympic::Settings[:match_primary_key]
+      has_and_belongs_to_many :teams,
+        class_name: Olympic::Settings[:team_class],
+        join_table: Olympic::Settings[:team_tournament_join],
+        foreign_key: Olympic::Settings[:tournament_join_key],
+        association_foreign_key: Olympic::Settings[:team_join_key]
+    end
+
+    module ClassMethods
+      def create_tournament(teams:, bracket:)
+        tournament = new
+        Olympic::Bracket.for(bracket, tournament, teams).call
+        tournament
+      end
+    end
+
+  end
+end

data/lib/olympic/version.rb

@@ -1,3 +1,3 @@
 module Olympic
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/olympic.gemspec

@@ -18,6 +18,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency 'rails', '>= 3.0', '< 5.1'
+  spec.add_dependency 'memoist', '~> 0.12'
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.1"
 end