bracket_tree 0.1.0

data/lib/bracket_tree/templates/single_elimination/8.json

@@ -0,0 +1,29 @@
+{
+  "matches":[
+    { "seats":[1,3], "winner_to":2, "loser_to":null },
+    { "seats":[5,7], "winner_to":6, "loser_to":null },
+    { "seats":[9,11], "winner_to":10, "loser_to":null },
+    { "seats":[13,15], "winner_to":14, "loser_to":null },
+    { "seats":[2,6], "winner_to":4, "loser_to":null },
+    { "seats":[10,14], "winner_to":12, "loser_to":null },
+    { "seats":[4,12], "winner_to":null, "loser_to":null }
+  ],
+  "seats":[
+    { "position": 8 },
+    { "position": 4 },
+    { "position": 12 },
+    { "position": 10 },
+    { "position": 14 },
+    { "position": 2 },
+    { "position": 6 },
+    { "position": 13 },
+    { "position": 15 },
+    { "position": 9 },
+    { "position": 11 },
+    { "position": 5 },
+    { "position": 7 },
+    { "position": 1 },
+    { "position": 3 }
+  ],
+  "starting_seats":[1,3,5,7,9,11,13,15]
+}

data/spec/bracket_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+
+describe BracketTree::Bracket::Base do
+  let(:bracket) { BracketTree::Bracket::Base.new }
+
+  describe '#initialize' do
+    it 'should create an array of Match objects if matches are passed' do
+      matches = [
+        { seats: [1,3], winner_to: 2, loser_to: nil },
+        { seats: [5,7], winner_to: 4, loser_to: nil },
+        { seats: [2,4], winner_to: 6, loser_to: nil }
+      ]
+      bracket = BracketTree::Bracket::Base.new matches: matches
+
+      bracket.matches.should be_a Array
+      bracket.matches.map(&:class).should == [BracketTree::Match, BracketTree::Match, BracketTree::Match]
+    end
+    
+    it 'should create an empty if matches are not passed' do
+      bracket.matches.should be_a Array
+      bracket.matches.should == []
+    end
+
+    it 'should assign the seed order if seed_order is passed' do
+      expected = [1,3,5,7]
+      bracket = BracketTree::Bracket::Base.new seed_order: expected
+      bracket.seed_order.should == expected
+    end
+  end
+
+  describe '#add' do
+    let(:root_payload) { { bar: 'bar' } }
+    let(:payload) { { foo: 'foo' } }
+
+    context 'no nodes present' do
+      before do
+        bracket.root.should be_nil
+        bracket.add 4, root_payload
+      end
+
+      it 'should create a new Node at root' do
+        bracket.root.should be_a_kind_of BracketTree::Node
+      end
+
+      it 'should set the payload of the new node to the passed object' do
+        bracket.root.payload.should == root_payload
+      end
+
+      it 'should set the position of the root node to the passed position' do
+        bracket.root.position.should == 4
+      end
+    end
+
+    context 'root node present' do
+      before do
+        bracket.add 4, root_payload
+        bracket.add 2, payload
+      end
+
+      it 'should add a node to the left position of root' do
+        bracket.root.left.should be_a_kind_of BracketTree::Node
+      end
+
+      it 'should have the payload of the new node' do
+        bracket.root.left.payload.should == payload
+      end
+
+      it 'should have the position of the new node' do
+        bracket.root.left.position.should == 2
+      end
+    end
+
+    context 'two nodes present' do
+      let(:new_payload) { { baz: 'baz' } }
+      before do
+        bracket.add 4, root_payload
+        bracket.add 2, payload
+
+        bracket.root.left.right.should be_nil
+        bracket.add 3, new_payload
+      end
+
+      it 'should add the new node to the left node right' do
+        bracket.root.left.right.should be_a_kind_of BracketTree::Node
+      end
+
+      it 'should add the payload of the new node' do
+        bracket.root.left.right.payload.should == new_payload
+      end
+
+      it 'should add the position of the new node' do
+        bracket.root.left.right.position.should == 3
+      end
+    end
+  end
+
+  describe '#seats' do
+    let(:bracket) { BracketTree::Bracket::SingleElimination.by_size 4 }
+
+    it 'should return 7 seats' do
+      bracket.seats.should have(7).seats
+    end
+
+    it 'should return them in insertion order' do
+      bracket.seats.map { |n| n.position }.should == bracket.insertion_order
+    end
+  end
+
+  describe '#replace' do
+    before do
+      bracket.add 3, { foo: 'foo' }
+      bracket.add 2, { bar: 'bar' }
+      bracket.add 4, { baz: 'baz' }
+    end
+
+    it 'replaces the payload at a given position with new payload' do
+      bracket.replace 3, { winner: 'me' }
+
+      bracket.root.payload.should == { winner: 'me' }
+      bracket.root.left.payload.should == { bar: 'bar' }
+      bracket.root.right.payload.should == { baz: 'baz' }
+    end
+  end
+
+  describe "#size" do
+    it "should return the number of nodes in the bracket" do
+      bracket.add 3, { foo: 'foo' }
+      bracket.add 2, { bar: 'bar' }
+      bracket.add 4, { baz: 'baz' }
+      bracket.size.should == 3
+    end
+  end
+
+  describe "#at" do
+    before do
+      bracket.add 3, { foo: 'foo' }
+      bracket.add 2, { bar: 'bar' }
+      bracket.add 1, { baz: 'baz' }
+    end
+    it "should return the node at the given position in the bracket" do
+      bracket.at(1).payload.should == { baz: 'baz'}
+      bracket.at(2).payload.should == { bar: 'bar'}
+      bracket.at(3).payload.should == { foo: 'foo'}
+    end
+  end
+
+  describe '#seed' do
+    let(:bracket) { BracketTree::Bracket::SingleElimination.by_size 4 }
+    let(:players) do
+      [
+        { name: 'player4' },
+        { name: 'player1' },
+        { name: 'player3' },
+        { name: 'player2' }
+      ]
+    end
+
+    it 'should place the players in the bracket by seed order' do
+      bracket.seed players
+
+      bracket.at(1).payload.should == { name: 'player4' }
+      bracket.at(3).payload.should == { name: 'player1' }
+      bracket.at(5).payload.should == { name: 'player3' }
+      bracket.at(7).payload.should == { name: 'player2' }
+    end
+
+    it 'should raise a NoSeedOrderError if seed order is not present in bracket' do
+      bracket.seed_order = nil
+
+      expect { bracket.seed players }.to raise_error(BracketTree::Bracket::NoSeedOrderError)
+    end
+
+    it 'should raise a SeedLimitExceededError if player count exceeds seed count' do
+      players << { name: 'player5' }
+      expect { bracket.seed players }.to raise_error(BracketTree::Bracket::SeedLimitExceededError)
+    end
+  end
+
+  describe '#match_winner' do
+    let(:bracket) { BracketTree::Bracket::DoubleElimination.by_size 4 }
+
+    it 'copies the seat data to the seat specified in the match winner_to' do
+      bracket.at(1).payload[:seed_value] = 1
+
+      bracket.match_winner 1
+      bracket.at(2).payload.should == bracket.at(1).payload
+    end
+  end
+end

data/spec/double_elimination_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe BracketTree::Template::DoubleElimination do
+  
+end

data/spec/match_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe BracketTree::Match do
+  it 'should log the seats if passed' do
+    match = BracketTree::Match.new seats: [1,2]
+    match.seats.should == [1,2]
+  end
+
+  it 'should log the winner_to if passed' do
+    match = BracketTree::Match.new winner_to: 1
+    match.winner_to.should == 1
+  end
+
+  it 'should log the loser_to if passed' do
+    match = BracketTree::Match.new loser_to: 1
+    match.loser_to.should == 1
+  end
+
+  describe '#include?' do
+    it 'should return true if seat is part of Match' do
+      match = BracketTree::Match.new seats: [1,2]
+      match.include?(1).should be_true
+    end
+
+    it 'should return false if seats is not part of Match' do
+      match = BracketTree::Match.new seats: [1,2]
+      match.include?(3).should be_false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'bracket_tree'

data/spec/template_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+class TestTemplate < BracketTree::Template::Base
+  def self.location
+    File.join File.dirname(__FILE__), '../', 'lib/bracket_tree/templates/single_elimination'
+  end
+end
+
+describe BracketTree::Template::Base do
+  def template_json
+    {
+      starting_seats: [1,3,5,7],
+      seats: [
+        { position: 4 },
+        { position: 2 },
+        { position: 6 },
+        { position: 1 },
+        { position: 3 },
+        { position: 5 },
+        { position: 7 }
+      ],
+      matches: []
+    }
+  end
+
+  describe '#by_size' do
+    it 'should return the Template based on the player size passed' do
+      template = TestTemplate.by_size 4
+
+      template.should be_a TestTemplate
+      template.seats.should have(7).seats
+      template.matches.should have(3).matches
+    end
+
+    it 'should return nil if template JSON does not exist' do
+      template = TestTemplate.by_size 5
+
+      template.should be_nil
+    end
+  end
+
+  describe '#from_json' do
+    it 'should generate the Template from the JSON template' do
+      template = TestTemplate.from_json template_json
+
+      template.should be_a TestTemplate
+      template.seats.should have(7).seats
+      template.starting_seats.should == [1,3,5,7]
+    end
+  end
+
+  describe '#to_h' do
+    it' should return a hash containing the bracket template' do
+      template = TestTemplate.from_json template_json
+      template.to_h.should == template_json
+    end
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: bracket_tree
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Andrew Nordman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70354606951940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70354606951940
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70354606967860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70354606967860
+description: Binary Tree based bracketing system
+email:
+- anordman@majorleaguegaming.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- bracket_tree.gemspec
+- lib/bracket_tree.rb
+- lib/bracket_tree/bracket.rb
+- lib/bracket_tree/bracket/base.rb
+- lib/bracket_tree/bracket/double_elimination.rb
+- lib/bracket_tree/bracket/single_elimination.rb
+- lib/bracket_tree/match.rb
+- lib/bracket_tree/node.rb
+- lib/bracket_tree/template.rb
+- lib/bracket_tree/templates/double_elimination.rb
+- lib/bracket_tree/templates/double_elimination/128.json
+- lib/bracket_tree/templates/double_elimination/16.json
+- lib/bracket_tree/templates/double_elimination/32.json
+- lib/bracket_tree/templates/double_elimination/4.json
+- lib/bracket_tree/templates/double_elimination/64.json
+- lib/bracket_tree/templates/double_elimination/8.json
+- lib/bracket_tree/templates/single_elimination.rb
+- lib/bracket_tree/templates/single_elimination/128.json
+- lib/bracket_tree/templates/single_elimination/16.json
+- lib/bracket_tree/templates/single_elimination/2.json
+- lib/bracket_tree/templates/single_elimination/32.json
+- lib/bracket_tree/templates/single_elimination/4.json
+- lib/bracket_tree/templates/single_elimination/64.json
+- lib/bracket_tree/templates/single_elimination/8.json
+- spec/bracket_spec.rb
+- spec/double_elimination_spec.rb
+- spec/match_spec.rb
+- spec/spec_helper.rb
+- spec/template_spec.rb
+homepage: https://github.com/agoragames/bracket_tree
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1286311622881667081
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1286311622881667081
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Binary Tree based bracketing system
+test_files:
+- spec/bracket_spec.rb
+- spec/double_elimination_spec.rb
+- spec/match_spec.rb
+- spec/spec_helper.rb
+- spec/template_spec.rb