olympic 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 137ae1004f177db1923172ff3f9083860d361871
-  data.tar.gz: ddfa7208b78f8040eb5d8bd3faf1257b871d6aba
+  metadata.gz: 8fc5a712fa617f6848bd48f1884a92edb90e861e
+  data.tar.gz: 70b248949c0213508364d451bc79ce7156001f83
 SHA512:
-  metadata.gz: c7c46cb6bb92473cee61f00ee75ffda261c4232f4bbb89fd6dc817cf57d170666a38cfe4541308ec6e4bd89eaa3719c372d9ac3fc93a194e08b5dc17b4c43ec7
-  data.tar.gz: 8a1203bceb68cd9690758f5d8a22ce29d9c590ec0fcf259f06d13586a16e051358df7afa041dff90410ce7cb344c9883f96425168bc50321359a83bd72ae3af5
+  metadata.gz: ad34729ac639b8086370cead8746cf4ba2dc24162b5ae0c74b113dc70013c99852d4fe011311d578531468940934669e43a3333cc345a53df8e7f5db68783c47
+  data.tar.gz: 238d2fd84dc60ae9984f77417cf83fb56032e171a37f0e459bcbd94162467c0a8a59b0a78ea7b24b1ef4cfc971c2d2c886574d047bc5fa1b85922452da58a938

data/.gitattributes

@@ -0,0 +1,17 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+
+# Custom for Visual Studio
+*.cs     diff=csharp
+
+# Standard to msysgit
+*.doc	 diff=astextplain
+*.DOC	 diff=astextplain
+*.docx diff=astextplain
+*.DOCX diff=astextplain
+*.dot  diff=astextplain
+*.DOT  diff=astextplain
+*.pdf  diff=astextplain
+*.PDF	 diff=astextplain
+*.rtf	 diff=astextplain
+*.RTF	 diff=astextplain

data/.rspec

@@ -0,0 +1,3 @@
+--color
+-f d
+-r spec_helper

data/Gemfile

@@ -1,4 +1,7 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in olympic.gemspec
 gemspec
+
+gem "sqlite3"
+gem "coveralls", require: false

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 medcat
+Copyright (c) 2014 Jeremy Rodi
 
 MIT License
 

data/Rakefile

@@ -1,2 +1,4 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 
+RSpec::Core::RakeTask.new('spec')

data/lib/generators/olympic/install/install_generator.rb

@@ -0,0 +1,22 @@
+module Olympic
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      desc "Create a migration to add olympic tables."
+      source_root File.expand_path("../templates", __FILE__)
+
+      # Implement the required interface for Rails::Generators::Migration.
+      # This is _literally_ documented _nowhere_.  Wtf.
+      def self.next_migration_number(dirname)
+        next_migration_number = current_migration_number(dirname) + 1
+        ActiveRecord::Migration.next_migration_number(next_migration_number)
+      end
+
+      def generate_migration
+        migration_template "create_olympic_tables.rb", "db/migrate/create_olympic_tables.rb"
+      end
+
+    end
+  end
+end

data/lib/generators/olympic/install/templates/create_olympic_tables.rb

@@ -0,0 +1,45 @@
+class CreateOlympicTables < ActiveRecord::Migration
+
+  def change
+    create_table :teams do |t|
+      # edit this.
+      <%- if Olympic::Settings.rating_system -%>
+      <%- Olympic::Settings.rating_system.required_fields.each do |key, value| -%>
+      t.<%= value.first %> <%= key.inspect %>, <%= value.last.inspect[1..-2] %>
+      <%- end -%>
+      <%- end -%>
+      raise NotImplementedError, "Update teams table in #{__FILE__}"
+    end
+
+    create_table :tournaments do |t|
+      t.string :bracket
+      t.integer :root_id
+    end
+
+    create_table :teams_tournaments, id: false do |t|
+      t.integer :team_id
+      t.integer :tournament_id
+    end
+
+    create_table :matches_teams, id: false do |t|
+      t.integer :match_id
+      t.integer :team_id
+    end
+
+    create_table :sources do |t|
+      t.integer :match_id
+      t.integer :source_id
+      t.string :source_type
+    end
+
+    create_table :matches do |t|
+      t.integer :tournament_id
+      t.integer :winner_id
+      t.integer :depth
+      t.integer :offset
+      t.integer :value
+      t.text :data
+    end
+  end
+
+end

data/lib/olympic.rb

@@ -1,3 +1,9 @@
+require "olympic/match"
+require "olympic/settings"
+require "olympic/rating"
+require "olympic/team"
+require "olympic/source"
+require "olympic/tournament"
 require "olympic/version"
 
 module Olympic

data/lib/olympic/bracket.rb

@@ -0,0 +1,20 @@
+require 'olympic/bracket/base'
+require 'olympic/bracket/single_elimination'
+require 'olympic/bracket/double_elimination'
+require 'olympic/bracket/round_robin'
+
+module Olympic
+  module Bracket
+
+    BRACKETS = {
+      single_elimination: SingleElimination,
+      double_elimination: DoubleElimination,
+      round_robin: RoundRobin
+    }
+
+    def self.for(name, tournament, teams)
+      BRACKETS.fetch(name).new(tournament, teams)
+    end
+
+  end
+end

data/lib/olympic/bracket/base.rb

@@ -0,0 +1,87 @@
+require 'olympic/bracket/single_elimination'
+
+module Olympic
+  module Bracket
+    # A basic bracket.  This defines the basic API that all brackets
+    # should have.  In order for a bracket to be compatible with
+    # Olympic, only these things need to be implemented.
+    class Base
+
+      # Initialize the bracket.
+      #
+      # @param tournament [Olympic::Tournament]
+      # @param teams [Array<Olympic::Team>]
+      def initialize(tournament, teams)
+        @tournament = tournament
+        @teams = teams
+      end
+
+      # @!method call
+      #   Initializes the tournament to handle the bracket.  Sets up
+      #   all matches and sources in accordance to the bracket
+      #   itself.
+      #
+      #   @return [void]
+      #
+      # @!method matches
+      #   Returns the number of expected matches in the bracket.  If
+      #   the number of matches is variable, it will return an array
+      #   of numbers, which contains potential values for the number
+      #   of matches in the bracket.
+      #
+      #   @return [Numeric, Array<Numeric>]
+      #
+      # @!method rounds
+      #   Returns the number of expected rounds in the bracket.  If
+      #   the number of rounds is variable, it will return an array
+      #   of numbers, which contains potential values for the number
+      #   of rounds in the bracket.
+      #
+      #   @return [Numeric, Array<Numeric>]
+      #
+      # @!method rounded_teams
+      #   In an elimination tournament, the number of teams has to be
+      #   rounded to the nearest power of two to calculate the number
+      #   of byes.  If this is not necessary, it will return the
+      #   number of teams.
+      #
+      #   @return [Numeric]
+      #
+      # @!method byes
+      #   The number of byes that are required in the bracket.  This
+      #   should be greater than or equal to zero.
+      #
+      #   @return [Numeric]
+      #
+      # @!method first_round_matches
+      #   The number of matches in the first round.  This will always
+      #   be a finite number, so this method will never return an
+      #   array of numbers.
+      #
+      #   @return [Numeric]
+      %(call matches rounds rounded_teams byes
+        first_round_matches).map(&:to_sym).each do |name|
+        define_method(name) do
+          _not_implemented_error(name)
+        end
+      end
+
+      private
+
+      # Raises an error stating that the given method wasn't
+      # implemented.  This is the default action the API methods on
+      # this class takes; a subclass should redefine the methods to
+      # perform an action.
+      #
+      # @note This should not be used outside of the base class.  If
+      #   A `NotImplementedError` is to be raised outside of the base
+      #   class, it should be raised with `raise`.
+      # @raise [NotImplementError] on call.
+      # @return [void]
+      def _not_implemented_error(name)
+        raise NotImplementedError, "`#{name}` is not implemented " \
+          "on `#{self.class}`"
+      end
+    end
+  end
+end

data/lib/olympic/bracket/single_elimination.rb

@@ -0,0 +1,54 @@
+require 'memoist'
+require 'olympic/bracket/single_elimination/information'
+
+module Olympic
+  module Bracket
+
+    # A single elimination tournament.  A single elimination
+    # tournament is a tournament of a set of teams in which the
+    # first loss results in elimination from the tournament.  Single
+    # elimination tournaments have the problem in which when the
+    # number of teams is not equal to a power of two, at least one bye
+    # is required.
+    class SingleElimination < Base
+      extend Memoist
+      include Information
+
+      # Creates a single elimination tournament, by setting up the
+      # needed matches (and their respective sources).
+      def call
+        matches = pair(initial_sources)
+        @tournament.root = matches.sort_by(&:depth).last
+      end
+
+      private
+
+      def pair(incoming, depth = 1)
+        round = incoming.each_slice(2).each_with_index.
+          map { |pair, i|
+            match = Settings.class_for(:match).
+              create(incoming: pair,
+                     tournament: @tournament,
+                     depth: depth,
+                     offset: i) }
+
+        if round.length > 1
+          outgoing = round.
+            map { |match| Settings.class_for(:source).create(source: match) }
+          round + pair(outgoing, depth + 1)
+        else
+          round
+        end
+      end
+
+      # The initial sources.  The "sources" in this case are the
+      # teams, which are mapped to an actual {Olympic::Source}.
+      #
+      # @return [Array<Olympic::Source>] The initial sources.
+      def initial_sources
+        @teams.map { |team| Settings.class_for(:source).create(source: team) }
+      end
+      memoize :initial_sources
+    end
+  end
+end

data/lib/olympic/bracket/single_elimination/information.rb

@@ -0,0 +1,45 @@
+require 'memoist'
+
+module Olympic
+  module Bracket
+    class SingleElimination
+
+      # General information about the tournament.
+      #
+      # @see Base
+      module Information
+        extend Memoist
+
+        # (see Base#matches)
+        def matches
+          @teams.size - 1
+        end
+        memoize :matches
+
+        # (see Base#rounds)
+        def rounds
+          Math.log2(@teams.size).ceil
+        end
+        memoize :rounds
+
+        # (see Base#rounded_teams)
+        def rounded_teams
+          2 ** rounds
+        end
+        memoize :rounded_teams
+
+        # (see Base#byes)
+        def byes
+          rounded_teams - @teams.size
+        end
+        memoize :byes
+
+        # (see Base#first_round_matches)
+        def first_round_matches
+          @teams.size - 2 ** Math.log2(@teams.size).floor
+        end
+        memoize :first_round_matches
+      end
+    end
+  end
+end

data/lib/olympic/coordinate/standard.rb

@@ -0,0 +1,17 @@
+module Olympic
+  module Coordinate
+    class Basic
+
+      # Initializes the coordinate.
+      #
+      # @param x [Numeric]
+      # @param y [Numeric]
+      # @param z [Numeric]
+      def initialize(x, y, z)
+        @x = x
+        @y = y
+        @z = z
+      end
+    end
+  end
+end

data/lib/olympic/error.rb

@@ -0,0 +1,7 @@
+module Olympic
+  class Error < StandardError; end
+
+  module Rating
+    class Error < Olympic::Error; end
+  end
+end

data/lib/olympic/match.rb

@@ -0,0 +1,71 @@
+module Olympic
+  module Match
+
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :tournament,
+        class_name:   Olympic::Settings[:tournament_class],
+        foreign_key:  Olympic::Settings[:match_tournament_key],
+        primary_key:  Olympic::Settings[:match_primary_key]
+      # An outgoing source is a source that this match is a part of.
+      # There are many of these, unfortunately.
+      has_many :outgoing,
+        class_name:   Olympic::Settings[:source_class],
+        foreign_key:  Olympic::Settings[:source_source_key],
+        foreign_type: Olympic::Settings[:source_source_type],
+        primary_key:  Olympic::Settings[:match_primary_key],
+        as: :sources
+      # An incoming source is a source that this match is owning.
+      # These are the sources that will participate in the match.
+      has_many :incoming,
+        class_name:   Olympic::Settings[:source_class],
+        foreign_key:  Olympic::Settings[:source_match_key],
+        primary_key:  Olympic::Settings[:match_primary_key]
+      belongs_to :winner,
+        class_name:   Olympic::Settings[:team_class],
+        foreign_key:  Olympic::Settings[:match_winner_key],
+        primary_key:  Olympic::Settings[:team_primary_key]
+    end
+
+    # If this match is ready to commence.  This means that the
+    # participants are defined.
+    #
+    # @return [Boolean]
+    def ready?
+      !!participants
+    end
+
+    # If this match has a winner defined; or, in other words, is
+    # completed.
+    #
+    # @return [Boolean]
+    def completed?
+      winner?
+    end
+
+    # Returns the teams that are a part of the match.  If the teams
+    # cannot be decided, it will return nil.
+    #
+    # @return [Array<Olympic::Team>, nil]
+    def participants
+      winners = incoming.includes(:source).map do |income|
+        source = income.source
+        case source
+        when Settings.class_for(:team)
+          source
+        when Settings.class_for(:match)
+          source.winner
+        else
+          raise Olympic::Error, "Unknown source #{source}"
+        end
+      end
+
+      if winners.any? { |winner| winner == nil }
+        nil
+      else
+        winners
+      end
+    end
+  end
+end