brackets 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef9e0f90d5ce9ae4ebd3193d0db4218463333415
-  data.tar.gz: 563f99e283542007f9b6b7528ef3ab20a4a5fbd9
+  metadata.gz: 6c83d7fafb937ee94ed9ae54cefa98cb2ed830c4
+  data.tar.gz: 990b94f69f4e57cb5ecb43804fefbe7cb1565e1c
 SHA512:
-  metadata.gz: 832d2402b34fe714a948d3aa71f79638617000d67d008fe9169b99606fb4b63b98e8d966f7f9891b112914dba4faf298edd8fe17cf6df75eb276946bbccfdb01
-  data.tar.gz: d6834ca5434be898119361a5f29ed32fe65239bfff393926a5dc2488d68af400b6f328dd5eb9453910d8262a23f500da989c6273d4d15edfe6584035b651581c
+  metadata.gz: 8187f943dbc8be7e3c96501966e2f506637fa5f1814308224018ea864409758454589cd98d14621a766d2eba4bbca7970c6cc58bb40b5a84873d4a49703b8146
+  data.tar.gz: 53213ef11e8cc68488f95be647d9bd373b6b74e9c1985cbbc93e4b544966a5ebed66ac2a104cd965a99d98afdc41da5e53247adc36a07a3bf894750fbb0063f7

data/.gitignore

@@ -0,0 +1,2 @@
+tmp/
+*.gem

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :test do
+  gem "rspec"
+  gem "guard-rspec"
+  gem "pry"
+end

data/Gemfile.lock

@@ -0,0 +1,67 @@
+PATH
+  remote: .
+  specs:
+    brackets (0.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    ffi (1.9.10)
+    formatador (0.2.5)
+    guard (2.13.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, <= 4.0)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.5.0)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    listen (3.0.4)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.9)
+    method_source (0.8.2)
+    nenv (0.2.0)
+    notiffany (0.0.8)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rb-fsevent (0.9.6)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    shellany (0.0.1)
+    slop (3.6.0)
+    thor (0.19.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  brackets!
+  guard-rspec
+  pry
+  rspec

data/Guardfile

@@ -0,0 +1,47 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features)
+
+## Uncomment to clear the screen before every task
+# clearing :on
+
+## Guard internally checks for changes in the Guardfile and exits.
+## If you want Guard to automatically start up again, run guard in a
+## shell loop, e.g.:
+##
+##  $ while bundle exec guard; do echo "Restarting Guard..."; done
+##
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
+end

data/brackets.gemspec

@@ -0,0 +1,17 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = 'brackets'
+  s.version       = '0.0.1'
+  s.date          = '2015-11-08'
+  s.summary       = "A gem to generate tournament brackets"
+  s.description   = "A gem to generate tournament brackets"
+  s.authors       = ["Vitor HP Bittencourt"]
+  s.email         = 'vitorhp2@gmail.com'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.require_paths = ["lib"]
+  s.homepage      = 'http://rubygems.org/gems/brackets'
+  s.license       = 'MIT'
+end

data/lib/brackets.rb

@@ -0,0 +1,8 @@
+module Brackets
+  autoload :Tournament, 'brackets/tournament'
+  autoload :Match, 'brackets/match'
+
+  module Util
+    autoload :BooleanCounter, 'brackets/util/boolean_counter'
+  end
+end

data/lib/brackets/match.rb

@@ -0,0 +1,19 @@
+module Brackets
+  class Match
+    attr_reader :winner, :deph, :number, :red, :blue
+
+    def initialize(deph = 0, number, red, blue)
+      @red, @blue, @deph, @number = red, blue, deph, number
+
+      @winner = blue.nil? ? red : nil
+    end
+
+    def placeholder?
+      @red.nil? && @blue.nil?
+    end
+
+    def to_s
+      "-"
+    end
+  end
+end

data/lib/brackets/tournament.rb

@@ -0,0 +1,76 @@
+module Brackets
+  class Tournament
+    def initialize(counter = Brackets::Util::BooleanCounter.new)
+      @counter = counter
+    end
+
+    def generate(competitors)
+      generate_rounds(generate_first_round(competitors))
+    end
+
+    private
+
+    def generate_first_round(competitors)
+      c = competitors.dup
+
+      if c.size == 1
+        [build_match(1, [c.first, nil])]
+      else
+        placeholder_matches = generate_placeholder_matches(c)
+        exceeding_matches = generate_exceeding_matches(c)
+        normal_matches = c.each_slice(2).map do |slice|
+          build_match(1, slice)
+        end
+
+        placeholder_matches.concat(exceeding_matches).concat(normal_matches)
+      end
+    end
+
+    def generate_rounds(round, deph = 2)
+      if round.size == 1
+        round
+      else
+        matches = round.select{|m| m.deph == deph - 1 }.each_slice(2).map do |slice|
+          build_match(deph, slice)
+        end
+
+        round.concat(generate_rounds(matches, deph + 1))
+      end
+    end
+
+    def build_match(deph = 0, competitors)
+      red, blue = competitors
+
+      Match.new(deph, @counter.next_if(deph > 0, nil), red, blue)
+    end
+
+    def generate_exceeding_matches(competitors)
+      matches = exceeding_number_of_players_for(competitors.size).times.map do
+        build_match(0, competitors.slice!(0, 2))
+      end
+
+      exceeding_player_matches = matches.map do
+        build_match(1, [competitors.slice!(0)])
+      end
+
+      matches.concat(exceeding_player_matches)
+    end
+
+    def generate_placeholder_matches(competitors)
+      placeholder_matches_count = power_of_two_after(competitors.size) - competitors.size
+
+      placeholder_matches_count.times.map do
+        build_match(0, [nil, nil])
+      end
+    end
+
+    def power_of_two_after(x, pow = 1)
+      2 ** pow >= x ? 2 ** pow : power_of_two_after(x, pow + 1)
+    end
+
+    def exceeding_number_of_players_for(size, pow = 1)
+      2 ** pow > size ? size - (2 ** (pow - 1)) : exceeding_number_of_players_for(size, pow + 1)
+    end
+
+  end
+end

data/lib/brackets/util/boolean_counter.rb

@@ -0,0 +1,13 @@
+module Brackets
+  module Util
+    class BooleanCounter
+      def initialize
+        @counter = 0
+      end
+
+      def next_if(boolean, falsey_value = nil)
+        boolean ? @counter += 1 : falsey_value || @counter
+      end
+    end
+  end
+end

data/spec/brackets/tournament_spec.rb

@@ -0,0 +1,113 @@
+module Brackets
+  describe Tournament do
+    let(:anakin) { double("anakin") }
+    let(:obiwan) { double("obiwan") }
+    let(:maul)   { double("maul") }
+    let(:mace)   { double("mace") }
+    let(:yoda)   { double("yoda") }
+    let(:shaak)  { double("shaak") }
+    let(:kit)    { double("kit") }
+    let(:plo)    { double("plo") }
+
+    describe "#generate_round" do
+
+      subject { Tournament.new.generate(competitors) }
+
+      let(:competitors) { [anakin, obiwan, maul, mace] }
+
+      it "numbers the matches sequentially" do
+        expect(subject.map(&:number)).to eq([1, 2, 3])
+      end
+
+      context "with one participant" do
+        let(:competitors) { [anakin] }
+
+        it "generates one match with the only participant being the winner" do
+          expect(subject.length).to eq(1)
+          expect(subject.first).to be_a(Match)
+          expect(subject.first.winner).to eq(anakin)
+        end
+      end
+
+      context "with two competitors" do
+        let(:competitors) { [anakin, obiwan] }
+
+        it "generates one match with no winner" do
+          expect(subject.length).to eq(1)
+          expect(subject.first).to be_a(Match)
+          expect(subject.first.winner).to be(nil)
+          expect(subject.first.red).to be(anakin)
+          expect(subject.first.blue).to be(obiwan)
+        end
+      end
+
+      context "when number of competitors is a power of two" do
+        let(:competitors) { [yoda, mace, anakin, obiwan] }
+
+        it "generates matches from subsequent rounds" do
+          expect(subject.size).to eq(3)
+          expect(subject.last.red).to be_a(Match)
+          expect(subject.last.blue).to be_a(Match)
+          expect(subject.last.red.red).to be(yoda)
+          expect(subject.last.red.blue).to be(mace)
+          expect(subject.last.blue.red).to be(anakin)
+          expect(subject.last.blue.blue).to be(obiwan)
+        end
+      end
+
+      context "when number of competitors is not a power of two" do
+        let(:competitors) { [yoda, mace, anakin, obiwan, maul] }
+
+        it "puts the exceeding competitors against winners of the first round" do
+          expect(subject.select{ |m| m.deph == 0 }.size).to eq(4)
+          expect(subject.select{ |m| m.deph == 1 }.size).to eq(2)
+          expect(subject.select{ |m| m.deph == 2 }.size).to eq(1)
+        end
+
+      end
+
+
+      # context "with three competitors" do
+      #   # TODO: Special case of three competitors
+      #   subject { Tournament.new.generate_round([anakin, obiwan, maul], 0, 1) }
+
+      #   it "generates three matches" do
+      #     expect(subject.length).to eq(3)
+      #   end
+
+      #   it "has no winners on the first match" do
+      #     expect(subject.first.winner).to eq(nil)
+      #   end
+
+      #   it "has a winner on the second match because there's only one guy" do
+      #     expect(subject[1].winner).not_to eq(nil)
+      #   end
+
+      #   it "generates a final match with one participant from the second match", focus: true do
+      #     expect(subject.last.red).to eq(nil)
+      #     expect(subject.last.blue).not_to eq(nil)
+      #   end
+
+      #   it "sets deph of match accordingly" do
+      #     expect(subject.first.deph).to eq(0)
+      #     expect(subject[1].deph).to eq(0)
+      #     expect(subject.last.deph).to eq(1)
+      #   end
+
+      #   it "numbers the matches sequentially" do
+      #     expect(subject.first.number).to eq(1)
+      #     expect(subject[1].number).to eq(2)
+      #     expect(subject.last.number).to eq(3)
+      #   end
+      # end
+
+      # context "when number of competitors is not a power of two" do
+      #   subject { Tournament.new.generate_round([yoda, mace, anakin, obiwan, maul], 1, 1) }
+
+      #   it "moves the remaining competitors to the second round" do
+      #     expect(subject.size).to eq(4)
+      #   end
+      # end
+    end
+  end
+end

data/spec/brackets/util/boolean_counter_spec.rb

@@ -0,0 +1,22 @@
+module Brackets::Util
+  describe BooleanCounter do
+    describe "#next_if" do
+      it "advances the counter when the param is true" do
+        expect(subject.next_if(true)).to eq(1)
+      end
+
+      it "keeps advancing if called multiple times" do
+        subject.next_if(true)
+        expect(subject.next_if(true)).to eq(2)
+      end
+
+      it "noes not advance the value when the param evals to false" do
+        expect(subject.next_if(false)).to eq(0)
+      end
+
+      it "returns the given value when param evals to false" do
+        expect(subject.next_if(false, "Nothing")).to eq("Nothing")
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'pry'
+require_relative "../lib/brackets.rb"
+
+RSpec.configure do |config|
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brackets
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Vitor HP Bittencourt
@@ -15,7 +15,20 @@ email: vitorhp2@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- brackets.gemspec
+- lib/brackets.rb
+- lib/brackets/match.rb
+- lib/brackets/tournament.rb
+- lib/brackets/util/boolean_counter.rb
+- spec/brackets/tournament_spec.rb
+- spec/brackets/util/boolean_counter_spec.rb
+- spec/spec_helper.rb
 homepage: http://rubygems.org/gems/brackets
 licenses:
 - MIT