bracket_graph 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a8a094e616df6e13af2293847ab029e6b492d41a
+  data.tar.gz: a5288ecdb4a357a7dadb8e4f83ed16ff99d873bf
+SHA512:
+  metadata.gz: 7ecaa3807b3900d97ecb09d9b48c018d84a78426d4ee1a0aa1a1154bc418bdb74ea78b34163be71a26863a88f25c7baa97befa608a45e9f37a529832fb790a9e
+  data.tar.gz: 49fa2118ba3892ee6f950bad065364a4f1a8d3ff5dd38794bda78c6dcf12ce46aac425ae5f0cfbeb021b84ac49552458bdd584f10a97c7c80c8996299201bbe9

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bracket_graph.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,24 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml|\.slim)$})          { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml|slim)$})     { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Nicola Racco
+
+MIT License
+
+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.md

@@ -0,0 +1,64 @@
+# BracketGraph
+
+Bracket Graph Library.
+
+It helps managing a graph for a single elimination bracket where each seat leads to a match that leads to a winner seat.
+
+## Single Elimination Bracket
+
+```ruby
+BracketGraph::Graph.new(bracket_size)
+```
+
+## About the Graph object
+
+```ruby
+graph.root # => BracketGraph::Seat for the final match
+graph.seats # => Array[BracketGraph::Seat] all nodes
+graph.starting_seats # => Array[BracketGraph::Seat] all starting nodes
+graph[12] # => BracketGraph::Seat with id/position 12
+graph.seed(teams) # => seeds each item in the given array to a starting node
+graph.seed(teams, shuffle: true) # => seeds teams after shuffle
+```
+
+## About the Graph nodes
+
+```ruby
+seat.from # Array[BracketGraph::Seat] source nodes. Empty array for a starting node
+seat.to # parent node. nil for the final node
+seat.position # node position id
+seat.payload # custom payload that can be also seeded via BracketGraph::Graph#seed
+```
+
+## Double Elimination Bracket
+
+```ruby
+BracketGraph::DoubleEliminationGraph.new(bracket_size)
+```
+
+## About the Graph objects
+
+```ruby
+graph.root # => BracketGraph::Seat for the final match
+graph.winner_graph # => BracketGraph::Graph for the the winner bracket
+graph.loser_graph # => BracketGraph::LoserGraph for the the loser bracket
+graph[12] # => BracketGraph::Seat with id/position 12
+graph.seed(teams) # => seeds each item in the given array to a starting node in the winner_graph
+graph.seed(teams, shuffle: true) # => seeds teams after shuffle
+```
+
+### Winner Graph object
+
+```ruby
+graph.winner_root # => BracketGraph::Seat for the final match of the winner bracket
+graph.winner_seats # => Array[BracketGraph::Seat] all nodes of the winner bracket
+graph.winner_starting_seats # => Array[BracketGraph::Seat] all starting nodes of the winner bracket
+```
+
+### Loser Graph object
+
+```ruby
+graph.loser_root # => BracketGraph::Seat for the final match of the loser bracket
+graph.loser_seats # => Array[BracketGraph::Seat] all nodes of the loser bracket
+graph.loser_starting_seats # => Array[BracketGraph::Seat] all starting nodes of the loser bracket
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bracket_graph.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bracket_graph/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bracket_graph"
+  spec.version       = BracketGraph::VERSION
+  spec.authors       = ["Nicola Racco"]
+  spec.email         = ["nicola@nicolaracco.com"]
+  spec.summary       = %q{Amazing brackets JSON representations.}
+  spec.description   = %q{Amazing, more or less, brackets in JSON.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "guard-rspec"
+end

data/lib/bracket_graph.rb

@@ -0,0 +1,12 @@
+require "active_support/all"
+
+require "bracket_graph/version"
+require "bracket_graph/team_seeder"
+require "bracket_graph/graph"
+require "bracket_graph/loser_graph"
+require "bracket_graph/seat"
+require "bracket_graph/double_elimination_graph"
+
+module BracketGraph
+  # Your code goes here...
+end

data/lib/bracket_graph/double_elimination_graph.rb

@@ -0,0 +1,122 @@
+module BracketGraph
+  class DoubleEliminationGraph
+    attr_reader :root
+    attr_reader :winner_graph, :loser_graph
+
+    def initialize root_or_size
+      if root_or_size.is_a? Seat
+        @root = root_or_size
+        @winner_graph = Graph.new @root.from[0]
+        @loser_graph = LoserGraph.new @root.from[1]
+      else
+        @winner_graph = Graph.new root_or_size
+        @loser_graph = LoserGraph.new root_or_size
+        sync_winner_rounds
+        sync_loser_rounds
+        build_final_seat
+        assign_loser_links
+      end
+    end
+
+    def [](position)
+      return root if position == root.position
+      if position < root.position
+        winner_graph[position]
+      else
+        loser_graph[position]
+      end
+    end
+
+    def size
+      winner_graph.size
+    end
+
+    %w(winner loser).each do |type|
+      define_method "#{type}_starting_seats" do
+        send("#{type}_graph").starting_seats
+      end
+
+      define_method "#{type}_seats" do
+        send("#{type}_graph").seats
+      end
+
+      define_method "#{type}_root" do
+        send("#{type}_graph").root
+      end
+    end
+
+    def seats
+      [root] + winner_seats + loser_seats
+    end
+
+    def starting_seats
+      winner_starting_seats + loser_starting_seats
+    end
+
+    def seed *args
+      winner_graph.seed *args
+    end
+
+    def as_json options={}
+      @root.as_json options
+    end
+
+    private
+
+    def build_final_seat
+      @root = Seat.new size * 2, round: loser_graph.root.round + 1
+      @root.from.concat [winner_graph.root, loser_graph.root]
+      @root.from.each { |s| s.to = @root }
+    end
+
+    def sync_winner_rounds
+      seats_by_round = winner_seats.inject({}) do |memo, seat|
+        memo[seat.round] ||= []
+        memo[seat.round] << seat
+        memo
+      end
+      3.upto(winner_root.round) do |round|
+        seats_by_round[round].each do |r|
+          r.instance_variable_set '@round', 2 + (round - 2) * 2
+        end
+      end
+    end
+
+    def sync_loser_rounds
+      loser_graph.seats.each do |s|
+        s.instance_variable_set '@round', s.round + 1
+      end
+    end
+
+    def winner_matches_by_round
+      winner_graph.seats.
+        reject(&:starting?).
+        sort_by(&:position).
+        inject({}) do |memo, seat|
+          memo[seat.round] ||= []
+          memo[seat.round] << seat
+          memo
+        end
+    end
+
+    def loser_starting_seats_by_round
+      loser_graph.starting_seats.sort_by(&:position).inject({}) do |memo, seat|
+        memo[seat.round] ||= []
+        memo[seat.round] << seat
+        memo
+      end
+    end
+
+    def assign_loser_links
+      winner_matches = winner_matches_by_round
+      loser_candidates = loser_starting_seats_by_round
+      winner_matches.each do |round, matches|
+        candidates = loser_candidates[round]
+        candidates.reverse! if round.even?
+        matches.each do |match|
+          match.loser_to = candidates.pop
+        end
+      end
+    end
+  end
+end

data/lib/bracket_graph/graph.rb

@@ -0,0 +1,89 @@
+module BracketGraph
+  class Graph
+    attr_reader :root
+    attr_reader :starting_seats, :seats
+
+    # Builds a new graph.
+    # The graph will be composed by a root seat and a match with two seats pointing to the root seat
+    # Each seat will then follows the same template (seat -> match -> 2 seats) until the generated
+    # last level seats (the starting seats) is equal to `size`.
+    #
+    # @param size [Fixnum|Seat] The number of orphan seats to generate, or the root node
+    # @raise [ArgumentError] if size is not a power of 2
+    def initialize root_or_size
+      if root_or_size.is_a? Seat
+        @root = root_or_size
+        update_references
+      else
+        raise ArgumentError, 'the given size is not a power of 2' if Math.log2(root_or_size) % 1 != 0
+        build_tree root_or_size
+      end
+    end
+
+    def [](position)
+      seats.detect { |s| s.position == position }
+    end
+
+    # Number of the starting seats
+    def size
+      starting_seats.size
+    end
+
+    # Fills the starting seats with the given `teams`
+    #
+    # @param teams [Array] Teams to place as payload in the starting seats
+    # @param shuffle [true, false] Indicates if teams shoud be shuffled
+    # @raise [ArgumentError] if `teams.count` is greater then `#size`
+    def seed teams, shuffle: false
+      raise ArgumentError, "Only a maximum of #{size} teams is allowed" if teams.size > size
+      slots = TeamSeeder.new(teams, size, shuffle: shuffle).slots
+      starting_seats.sort_by(&:position).each do |seat|
+        seat.payload = slots.shift
+      end
+    end
+
+    def as_json *attrs
+      @root.as_json *attrs
+    end
+
+    private
+
+    def build_tree size
+      build_tree! size
+      update_references
+    end
+
+    def build_tree! size
+      @root = Seat.new size, round: Math.log2(size).to_i
+      # Math.log2(size) indicates the graph depth
+      Math.log2(size).to_i.times.inject [root] do |seats|
+        seats.inject [] do |memo, seat|
+          memo.concat create_children_of seat
+        end
+      end
+
+    end
+
+    def update_references
+      @seats = [root]
+      @starting_seats = []
+      nodes = [root]
+      while nodes.any?
+        @seats.concat nodes = nodes.map(&:from).flatten
+      end
+      @starting_seats = @seats.select { |s| s.from.empty? }
+    end
+
+    # Builds a match as a source of this seat
+    # @raise [NoMethodError] if a source match has already been set
+    def create_children_of seat
+      raise NoMethodError, 'children already built' if seat.from.any?
+      parent_position = seat.to ? seat.to.position : 0
+      relative_position_halved = ((seat.position - parent_position) / 2).abs
+      seat.from.concat [
+        Seat.new(seat.position - relative_position_halved, to: seat),
+        Seat.new(seat.position + relative_position_halved, to: seat)
+      ]
+    end
+  end
+end

data/lib/bracket_graph/loser_graph.rb

@@ -0,0 +1,56 @@
+require "bracket_graph/graph"
+
+module BracketGraph
+  class LoserGraph < Graph
+    class IdGenerator
+      attr_reader :current
+
+      def initialize starting_id = 0
+        @current = starting_id
+      end
+
+      def next
+        @current += 1
+      end
+    end
+
+    def initialize root_or_size
+      raise ArgumentError, 'a loser graph require at least 4 participants' if root_or_size.is_a?(Fixnum) && root_or_size < 4
+      super
+    end
+
+    def size
+      starting_seats.count + 1
+    end
+
+    private
+
+    def build_tree size
+      id_generator = IdGenerator.new size * 2 + 1
+      @root = Seat.new id_generator.next, round: 2 * Math.log2(size).to_i - 2
+      expected_rounds = 2 * (Math.log2(size).to_i - 1)
+      expected_rounds.times.inject [root] do |seats, round|
+        seats.each_with_index.inject [] do |memo, (seat, index)|
+          children = create_children_of seat, id_generator
+          side_count = (seats.count / 2.0).ceil
+          if round.even?
+            memo << children[index % side_count >= (side_count / 2.0).ceil ? 0 : 1]
+          else
+            memo.concat children
+          end
+        end
+      end
+      update_references
+    end
+
+    # Builds a match as a source of this seat
+    # @raise [NoMethodError] if a source match has already been set
+    def create_children_of seat, id_generator
+      raise NoMethodError, 'children already built' if seat.from.any?
+      seat.from.concat [
+        Seat.new(id_generator.next, to: seat),
+        Seat.new(id_generator.next, to: seat)
+      ]
+    end
+  end
+end

data/lib/bracket_graph/seat.rb

@@ -0,0 +1,60 @@
+module BracketGraph
+  class Seat
+    # Source match for this seat
+    attr_reader :from
+    # Seat position in the graph. It acts like an Id
+    attr_reader :position
+    # Seat payload. It should be used to keep track of the player and of its status in this seat
+    attr_accessor :payload
+    # Destination match of this seat.
+    attr_accessor :to
+    # Destination match of this seat for the loser participant.
+    attr_accessor :loser_to
+
+    # Creates a new seat for the bracket graph.
+    #
+    # @param position [Fixnum] Indicates the Seat position in the graph and acts like an Id
+    # @param to [BracketGraph::Match] The destination match. By default it's nil (and this node will act like the root node)
+    def initialize position, to: nil, round: nil
+      round ||= to.round - 1 if to
+      @position, @to, @round = position, to, round
+      @from = []
+    end
+
+    def starting?
+      from.nil? || from.empty?
+    end
+
+    def final?
+      to.nil?
+    end
+
+    # Graph depth until this level. If there is no destination it will return 0, otherwise it will return the destionation depth
+    def depth
+      @depth ||= to && to.depth + 1 || 0
+    end
+
+    # Round is the opposite of depth. While depth is 0 in the root node and Math.log2(size) at the lower level
+    # round is 0 at the lower level and Math.log2(size) in the root node
+    # While depth is memoized, round is calculated each time. If the seat has a source, it's the source round + 1, otherwise it's 0
+    def round
+      @round || (to ? to.round - 1 : 0)
+    end
+
+    def as_json options = {}
+      data = { position: position, round: round }
+      data.update payload: payload if payload
+      data.update loser_to: loser_to.position if loser_to
+      from && data.update(from: from.map(&:as_json)) || data
+    end
+
+    def inspect
+      """#<BracketGraph::Seat:#{position}
+      @from=#{from.map(&:position).inspect}
+      @round=#{round}
+      @to=#{(to && to.position || nil).inspect}
+      @loser_to=#{(loser_to && loser_to.position || nil).inspect}
+      @payload=#{payload.inspect}>"""
+    end
+  end
+end

data/lib/bracket_graph/team_seeder.rb

@@ -0,0 +1,57 @@
+class TeamSeeder
+  attr_reader :size
+
+  def initialize teams, size, shuffle: false
+    @teams = shuffle && teams.shuffle || teams.dup
+    @size = size
+  end
+
+  def slots
+    return @slots if @slots
+    @slots = [true] * size
+    seed_byes
+    seed_teams
+    @slots
+  end
+
+  private
+
+  def seed_byes
+    byes_to_seed = size - @teams.length
+    return if byes_to_seed == 0
+    @slots[0] = nil
+    seed_byes_by_partition byes_to_seed - 1 if byes_to_seed > 1
+  end
+
+  def seed_teams
+    @slots.each_with_index do |slot_value, index|
+      @slots[index] = @teams.shift if slot_value == true
+    end
+  end
+
+  def seed_byes_by_partition byes
+    partition = nil
+    byes.times do
+      partition = largest_bye_partition
+      mid_index = partition.min + ((partition.max.to_f - partition.min) / 2).ceil
+      @slots[mid_index] = nil
+    end
+  end
+
+  def largest_bye_partition
+    start_index, end_index = nil, nil
+    prev_index = 0
+    @slots.each_with_index do |value, index|
+      next if index > 0 && index < @slots.count - 1 && value
+      if start_index.nil?
+        start_index = index
+      elsif end_index.nil?
+        end_index = index
+      elsif index - prev_index > end_index - start_index
+        start_index, end_index = prev_index, index
+      end
+      prev_index = index
+    end
+    Range.new start_index, end_index
+  end
+end

data/lib/bracket_graph/version.rb

@@ -0,0 +1,3 @@
+module BracketGraph
+  VERSION = "0.0.2"
+end

data/spec/lib/bracket_graph/double_elimination_graph_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe BracketGraph::DoubleEliminationGraph do
+  it 'creates a graph composed by winner and loser graphs' do
+    subject = described_class.new 8
+    expect(subject.winner_graph).to be_a BracketGraph::Graph
+    expect(subject.loser_graph).to be_a BracketGraph::LoserGraph
+  end
+
+  it 'creates both the sub-graphs with the same size' do
+    subject = described_class.new 8
+    expect(subject.winner_graph.size).to eq 8
+    expect(subject.loser_graph.size).to eq 8
+  end
+
+  it 'creates a real final node' do
+    subject = described_class.new 8
+    expect(subject.root).to be_a BracketGraph::Seat
+  end
+
+  it 'binds both the sub-graph roots as children of the real final node' do
+    subject = described_class.new 8
+    expect(subject.winner_graph.root.to).to eq subject.root
+    expect(subject.loser_graph.root.to).to eq subject.root
+    expect(subject.root.from).to eq [subject.winner_graph.root, subject.loser_graph.root]
+  end
+
+  it 'creates the final node with doubled size as position' do
+    subject = described_class.new 8
+    expect(subject.root.position).to eq 16
+  end
+
+  it 'creates the final node in the last round' do
+    subject = described_class.new 8
+    expect(subject.root.round).to eq 6
+  end
+
+  it 'syncs the rounds of the winner bracket' do
+    subject = described_class.new 16
+    memo = subject.winner_graph.seats.inject(Hash.new { |h, k| h[k] = [] }) do |m, s|
+      m[s.round] << s
+      m
+    end
+    expect(memo[0].count).to eq 16
+    expect(memo[1].count).to eq 8
+    expect(memo[2].count).to eq 4
+    expect(memo[3].count).to be_zero
+    expect(memo[4].count).to eq 2
+    expect(memo[5].count).to be_zero
+    expect(memo[6].count).to eq 1
+  end
+
+  it 'syncs the rounds of the loser bracket' do
+    subject = described_class.new 16
+    memo = subject.loser_graph.seats.inject(Hash.new { |h, k| h[k] = [] }) do |m, s|
+      m[s.round] << s
+      m
+    end
+    expect(memo[0].count).to be_zero
+    expect(memo[1].count).to eq 8
+    expect(memo[2].count).to eq 8
+    expect(memo[3].count).to eq 4
+    expect(memo[4].count).to eq 4
+    expect(memo[5].count).to eq 2
+    expect(memo[6].count).to eq 2
+    expect(memo[7].count).to eq 1
+  end
+
+  it 'after the sync the winner final is one round behind the real final' do
+    subject = described_class.new 16
+    expect(subject.loser_graph.root.round).to eq 7
+    expect(subject.winner_graph.root.round).to eq 6
+  end
+
+  describe '#size' do
+    it 'returns the right size' do
+      subject = described_class.new 8
+      expect(subject.size).to eq 8
+    end
+  end
+
+  describe '#starting_seats' do
+    it 'returns the sum of starting seats' do
+      subject = described_class.new 8
+      expect(subject.starting_seats).to match_array subject.winner_graph.starting_seats + subject.loser_graph.starting_seats
+    end
+  end
+
+  describe '#seats' do
+    it 'returns the sum of seats' do
+      subject = described_class.new 8
+      expect(subject.seats).to match_array [subject.root] + subject.winner_graph.seats + subject.loser_graph.seats
+    end
+
+    it 'returns the root node too' do
+      subject = described_class.new 8
+      expect(subject.seats).to include subject.root
+    end
+  end
+
+  describe '#seed' do
+    it 'delegates to the winner graph' do
+      subject = described_class.new 8
+      allow(subject.winner_graph).to receive(:seed).and_return 'foo'
+      expect(subject.seed).to eq 'foo'
+    end
+  end
+
+  it 'correctly dumps to json' do
+    subject = described_class.new(4).as_json
+    expect(subject).to be_a Hash
+    expect(subject[:from]).to be_a Array
+  end
+
+  it 'correctly saves and restores' do
+    data = Marshal::dump described_class.new(4)
+    subject = Marshal::load data
+    expect(subject.starting_seats.count).to eq 7
+  end
+
+  it 'assigns a loser to to each match' do
+    subject = described_class.new 16
+    candidates = subject.winner_seats - subject.winner_starting_seats
+    expect(candidates.select(&:loser_to).count).to eq candidates.count
+  end
+
+  it 'assigns only loser starting seats in the loser relationship' do
+    subject = described_class.new 16
+    candidates = subject.winner_seats - subject.winner_starting_seats
+    expect(candidates.map(&:loser_to)).to match_array subject.loser_starting_seats
+  end
+
+  it 'assigns each loser_to to a different seat' do
+    subject = described_class.new 16
+    candidates = subject.winner_seats - subject.winner_starting_seats
+    expect(candidates.map(&:loser_to).uniq.count).to eq candidates.count
+  end
+
+  it 'assigns loser_to links in a different order using the round oddity' do
+    subject = described_class.new 16
+    candidates = (subject.winner_seats - subject.winner_starting_seats).sort_by &:position
+    (1..subject.winner_root.round).each do |round|
+      round_candidates_positions = candidates.
+        select { |s| s.round == round }.
+        map { |c| c.loser_to.position }
+      if round.odd?
+        expect(round_candidates_positions).to eq round_candidates_positions.sort.reverse
+      else
+        expect(round_candidates_positions).to eq round_candidates_positions.sort
+      end
+    end
+  end
+end

data/spec/lib/bracket_graph/graph_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+describe BracketGraph::Graph do
+  describe 'constructor' do
+    it 'creates instance with a certain size' do
+      expect { described_class.new 128 }.to_not raise_error
+    end
+
+    it 'raises error if size is not a power of 2' do
+      expect { described_class.new 3 }.to raise_error ArgumentError
+    end
+
+    it 'creates a root seat node' do
+      subject = described_class.new 4
+      expect(subject.root).to be_a BracketGraph::Seat
+    end
+
+    it 'appends two seats as input in the root match node' do
+      subject = described_class.new 4
+      expect(subject.root.from.map(&:class)).to eq [BracketGraph::Seat,BracketGraph::Seat]
+    end
+
+    it 'follows this pattern until the last level children count is equal to the graph size' do
+      subject = described_class.new 128
+      nodes = 7.times.inject([subject.root]) do |current_nodes|
+        current_nodes.inject([]) do |memo, node|
+          expect(node.from.count).to eq 2
+          memo.concat node.from
+        end
+      end
+      expect(nodes.count).to eq 128
+      nodes.each { |node| expect(node.from).to be_empty }
+    end
+
+    it 'sets depths starting from 0' do
+      subject = described_class.new 128
+      expect(subject.root.depth).to eq 0
+    end
+
+    it 'sets depths ending to log2 of size' do
+      subject = described_class.new 128
+      expect(subject.starting_seats.map(&:depth).uniq).to eq [7]
+    end
+
+    it 'sets rounds starting from log2 of size' do
+      subject = described_class.new 128
+      expect(subject.root.round).to eq 7
+    end
+
+    it 'sets rounds ending to 0' do
+      subject = described_class.new 128
+      expect(subject.starting_seats.map(&:round).uniq).to eq [0]
+    end
+
+    it 'sets root position to size' do
+      subject = described_class.new 64
+      expect(subject.root.position).to eq 64
+    end
+
+    it 'sets source seats (through the match) to size - (size / 2) and size + (size / 2)' do
+      subject = described_class.new 64
+      children = subject.root.from
+      expect(children.map(&:position).sort).to eq [32,96]
+    end
+
+    it 'does not duplicate positions' do
+      subject = described_class.new 128
+      expect(subject.seats.map(&:position).uniq.count).to eq subject.seats.count
+    end
+
+    it 'creates a graph given its root node' do
+      existing = described_class.new 4
+      subject = described_class.new existing.root
+      expect(subject.starting_seats).to eq existing.starting_seats
+    end
+
+    it 'always sets the children by position order' do
+      subject = described_class.new 32
+      positions_groups = subject.seats.map { |s| s.from.map &:position }
+      positions_groups.each do |position_group|
+        expect(position_group).to eq position_group.sort
+      end
+    end
+  end
+
+  describe '#starting_seats' do
+    it 'returns a collection of the given size' do
+      subject = described_class.new 128
+      expect(subject.starting_seats.count).to eq 128
+    end
+
+    it 'returns a collection of seats' do
+      subject = described_class.new 8
+      expect(subject.starting_seats.map(&:class).uniq).to eq [BracketGraph::Seat]
+    end
+
+    it 'returns the last level seats' do
+      subject = described_class.new 8
+      subject.starting_seats.each do |seat|
+        expect(seat.from).to be_empty
+      end
+    end
+  end
+
+  describe '#seed' do
+    it 'raises error if there are more teams than starting seats' do
+      subject = described_class.new 4
+      expect { subject.seed [1,2,3,4,5] }.to raise_error ArgumentError
+    end
+
+    it 'assigns the given teams to the starting seats' do
+      subject = described_class.new 4
+      subject.seed [1,2,3,4]
+      expect(subject.starting_seats.map(&:payload)).to match_array [1,2,3,4]
+    end
+
+    it 'does not change the given array' do
+      subject = described_class.new 4
+      array = [1,2,3,4]
+      expect { subject.seed array }.to_not change array, :count
+    end
+
+    it 'fills seats by position' do
+      subject = described_class.new 4
+      subject.seed [1,2,3,4]
+      expect(subject.starting_seats.sort_by(&:position).map(&:payload)).to eq [1,2,3,4]
+    end
+
+    it 'leaves remaining seats with a nil payload' do
+      subject = described_class.new 4
+      subject.seed [1,2,3]
+      expect(subject.starting_seats.sort_by(&:position).map(&:payload)).to eq [nil,1,2,3]
+    end
+
+    it 'uses the TeamSeeder' do
+      subject = described_class.new 4
+      expect_any_instance_of(TeamSeeder).to receive(:slots).and_return []
+      subject.seed [1,2,3,4], shuffle: true
+    end
+  end
+
+  describe '#[]' do
+    it 'return the seat with the given position' do
+      subject = described_class.new 8
+      expect(subject[6].position).to eq 6
+    end
+  end
+
+  describe '#seats' do
+    it 'returns seats' do
+      subject = described_class.new 8
+      expect(subject.seats.map(&:class).uniq).to eq [BracketGraph::Seat]
+    end
+
+    it 'returns all generated seats' do
+      subject = described_class.new 8
+      expect(subject.seats.count).to eq 15
+    end
+
+    it 'returns the root node too' do
+      subject = described_class.new 8
+      expect(subject.seats).to include subject.root
+    end
+  end
+end

data/spec/lib/bracket_graph/loser_graph_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe BracketGraph::LoserGraph do
+  describe 'constructor' do
+    it 'creates instance with a certain size' do
+      expect { described_class.new 128 }.to_not raise_error
+    end
+
+    it 'raises error if size is not a power of 2' do
+      expect { described_class.new 5 }.to raise_error ArgumentError
+    end
+
+    it 'raises error if size is lower than 4' do
+      expect { described_class.new 2 }.to raise_error ArgumentError
+    end
+
+    it 'creates a root seat node' do
+      subject = described_class.new 4
+      expect(subject.root).to be_a BracketGraph::Seat
+    end
+
+    it 'appends two seats as input in the root match node' do
+      subject = described_class.new 4
+      expect(subject.root.from.map(&:class)).to eq [BracketGraph::Seat,BracketGraph::Seat]
+    end
+
+    it 'one of the root children is a starting seat' do
+      subject = described_class.new 4
+      expect(subject.root.from.map(&:from)).to include []
+    end
+
+    it 'the children of the match child of root are starting seats' do
+      subject = described_class.new 4
+      expect(subject.root.from.map(&:from).flatten.map(&:from).flatten).to be_empty
+    end
+
+    it 'follows this pattern until the last level children count is equal to the graph size' do
+      subject = described_class.new 128
+      nodes = 6.times.inject([subject.root]) do |current_nodes|
+        current_nodes.inject([]) do |memo, node|
+          expect(node.from.count).to eq 2
+          sub_children = node.from.map &:from
+          expect(sub_children).to include []
+          expect(sub_children.flatten.count).to eq 2
+          memo.concat sub_children.flatten
+        end
+      end
+      expect(nodes.count).to eq 64
+      nodes.each { |node| expect(node.from).to be_empty }
+    end
+
+    it 'sets depths starting from 0' do
+      subject = described_class.new 128
+      expect(subject.root.depth).to eq 0
+    end
+
+    it 'contains starting seats in even seats' do
+      subject = described_class.new 128
+      expect(subject.starting_seats.map(&:depth).uniq).to eq [1,3,5,7,9,11,12]
+    end
+
+    it 'sets rounds starting from 2 per log2 of size - 1' do
+      subject = described_class.new 128
+      expect(subject.root.round).to eq 12
+    end
+
+    it 'contains starting seats in odd seats' do
+      subject = described_class.new 128
+      expect(subject.starting_seats.map(&:round).uniq).to eq [11,9,7,5,3,1,0]
+    end
+
+    it 'sets root position to doubled size + 2' do
+      subject = described_class.new 64
+      expect(subject.root.position).to eq 130
+    end
+
+    it 'sets the position of root children to root position +1 and +2' do
+      subject = described_class.new 64
+      expect(subject.root.from.map(&:position)).to match_array [131,132]
+    end
+
+    it 'sets source seats (through the match) positions' do
+      subject = described_class.new 64
+      children = subject.root.from[1].from
+      expect(children.map(&:position).sort).to eq [133, 134]
+    end
+
+    it 'does not duplicate positions' do
+      subject = described_class.new 16
+      expect(subject.seats.map(&:position).uniq.count).to eq subject.seats.count
+    end
+
+    it 'creates a graph given its root node' do
+      existing = described_class.new 4
+      subject = described_class.new existing.root
+      expect(subject.starting_seats).to eq existing.starting_seats
+    end
+  end
+
+  describe '#starting_seats' do
+    it 'returns a collection of the given size - 1' do
+      subject = described_class.new 128
+      expect(subject.starting_seats.count).to eq 127
+    end
+
+    it 'returns a collection of seats' do
+      subject = described_class.new 8
+      expect(subject.starting_seats.map(&:class).uniq).to eq [BracketGraph::Seat]
+    end
+
+    it 'returns the last level seats' do
+      subject = described_class.new 8
+      subject.starting_seats.each do |seat|
+        expect(seat.from).to be_empty
+      end
+    end
+  end
+
+  describe '#[]' do
+    it 'return the seat with the given position' do
+      subject = described_class.new 8
+      expect(subject[22].position).to eq 22
+    end
+  end
+
+  describe '#seats' do
+    it 'returns seats' do
+      subject = described_class.new 8
+      expect(subject.seats.map(&:class).uniq).to eq [BracketGraph::Seat]
+    end
+
+    it 'returns all generated seats' do
+      subject = described_class.new 8
+      expect(subject.seats.count).to eq 13
+    end
+
+    it 'returns the root node too' do
+      subject = described_class.new 8
+      expect(subject.seats).to include subject.root
+    end
+  end
+end

data/spec/lib/bracket_graph/seat_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe BracketGraph::Seat do
+  let(:subject_class) { BracketGraph::Seat }
+  let(:subject) { subject_class.new 10 }
+
+  describe 'constructor' do
+    it 'raises error if position is nil' do
+      expect { subject_class.new }.to raise_error ArgumentError
+    end
+
+    it 'requires position' do
+      subject = subject_class.new 10
+      expect(subject.position).to eq 10
+    end
+
+    it 'accepts the destination' do
+      dest = subject_class.new 12
+      expect(subject_class.new(10, to: dest).to).to eq dest
+    end
+
+    it 'allows the destination to not be set' do
+      expect { subject_class.new 10 }.to_not raise_error
+    end
+  end
+
+  describe '#depth' do
+    it 'is 0 when the seat has no destination' do
+      expect(subject_class.new(10).depth).to eq 0
+    end
+
+    it 'equals destination_depth + 1when destination is set' do
+      destination = double 11, depth: 10, round: 9
+      expect(subject_class.new(10, to: destination).depth).to eq 11
+    end
+  end
+
+  describe '#round' do
+    it 'returns 0 if seat has no source' do
+      expect(subject_class.new(10).round).to be_zero
+    end
+
+    it 'returns parent round - 1 if a parent exists' do
+      allow(subject).to receive(:to) { double(round: 10) }
+      expect(subject.round).to eq 9
+    end
+  end
+
+  describe '#as_json' do
+    subject { described_class.new 10, round: 10 }
+
+    it 'returns a json representation' do
+      expect { subject.as_json }.to_not raise_error
+    end
+
+    it 'returns position' do
+      expect(subject.as_json[:position]).to eq 10
+    end
+
+    it 'returns source matches' do
+      subject.from[0] = described_class.new 11, to: subject
+      expect(subject.as_json.key? :from).to be_truthy
+    end
+
+    it 'returns payload' do
+      subject.payload = { id: 9 }
+      expect(subject.as_json[:payload]).to eq :id => 9
+    end
+  end
+
+  describe '#starting?' do
+    subject { described_class.new 10, round: 10 }
+
+    it 'returns true if there are no children' do
+      expect(subject).to be_starting
+    end
+
+    it 'returns false if there are children' do
+      subject.from << double
+      expect(subject).not_to be_starting
+    end
+
+    it 'returns true if #from is nil' do
+      subject.instance_variable_set '@from', nil
+      expect(subject).to be_starting
+    end
+  end
+
+  describe '#final?' do
+    subject { described_class.new 10, round: 10 }
+
+    it 'returns true if there is no parent seat' do
+      expect(subject).to be_final
+    end
+
+    it 'returns false if there is a parent seat' do
+      subject.to = double
+      expect(subject).not_to be_final
+    end
+  end
+end

data/spec/lib/bracket_graph/team_seeder_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe TeamSeeder do
+  it 'shuffles teams if shuffle is true' do
+    subject = TeamSeeder.new ['a','b','c'], 4, shuffle: true
+    teams = subject.instance_variable_get '@teams'
+    expect(teams).to_not eq ['a','b','c']
+  end
+
+  it 'does not shuffle teams if shuffle is false' do
+    subject = TeamSeeder.new ['a','b','c'], 4
+    teams = subject.instance_variable_get '@teams'
+    expect(teams).to eq ['a','b','c']
+  end
+
+  describe '#slots' do
+    let(:teams) { %w(a b c d e f g h i j k l m) }
+    subject { TeamSeeder.new teams, 16 }
+
+    it 'returns an array' do
+      expect(subject.slots).to be_a Array
+    end
+
+    it 'returns an array of {slots} length' do
+      expect(subject.slots.length).to eq 16
+    end
+
+    it 'inserts {slots} - {teams} byes' do
+      expect(subject.slots.select(&:nil?).count).to eq 3
+    end
+
+    it 'inserts the first bye at the first position' do
+      expect(subject.slots[0]).to be_nil
+    end
+
+    it 'inserts byes using the mid point of the large partition recursively' do
+      expect(subject.slots).to eq [nil, 'a', 'b', 'c', nil, 'd', 'e', 'f', nil,
+                                  'g', 'h', 'i', 'j', 'k', 'l', 'm']
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.expand_path '../../lib/bracket_graph', __FILE__

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: bracket_graph
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Nicola Racco
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Amazing, more or less, brackets in JSON.
+email:
+- nicola@nicolaracco.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bracket_graph.gemspec
+- lib/bracket_graph.rb
+- lib/bracket_graph/double_elimination_graph.rb
+- lib/bracket_graph/graph.rb
+- lib/bracket_graph/loser_graph.rb
+- lib/bracket_graph/seat.rb
+- lib/bracket_graph/team_seeder.rb
+- lib/bracket_graph/version.rb
+- spec/lib/bracket_graph/double_elimination_graph_spec.rb
+- spec/lib/bracket_graph/graph_spec.rb
+- spec/lib/bracket_graph/loser_graph_spec.rb
+- spec/lib/bracket_graph/seat_spec.rb
+- spec/lib/bracket_graph/team_seeder_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.7
+signing_key: 
+specification_version: 4
+summary: Amazing brackets JSON representations.
+test_files:
+- spec/lib/bracket_graph/double_elimination_graph_spec.rb
+- spec/lib/bracket_graph/graph_spec.rb
+- spec/lib/bracket_graph/loser_graph_spec.rb
+- spec/lib/bracket_graph/seat_spec.rb
+- spec/lib/bracket_graph/team_seeder_spec.rb
+- spec/spec_helper.rb