goose_game 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4f64052a54488a4f601033db2224d893561aa9b7ec8b7aea84fa6db727681735
+  data.tar.gz: c69991536320fc33304f6f2eaf26b086ac699c745706aaf2a403a2266704a6ea
+SHA512:
+  metadata.gz: b7049f937781cc2529db050a1c8adbd767c493c6bf4c83e60d6620518e5504a39d4318837021a2c22cae472c951de2a6c3f272500800ddabdeda1d8fb966f68a
+  data.tar.gz: b6082175df2a8a3df33f1c2d04dc7b93bfbc2bdc239af0e0106ec2ee80972652a0f286039926c0815566740aa91c1d21a702f3a62214458806b89d079dbd7c68

data/.gitignore

@@ -0,0 +1,50 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.travis.yml

@@ -0,0 +1,7 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+  - 2.5.1
+  - 2.6.3
+before_install: gem install bundler -v 2.0.2

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    goose_game (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.11.3)
+    rake (12.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  goose_game!
+  minitest (~> 5.11)
+  rake (~> 12.3)
+
+BUNDLED WITH
+   2.0.2

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2019 The Python Packaging Authority
+
+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/OBJECTIVES.md

@@ -0,0 +1,124 @@
+# The Goose Game Kata
+Goose game is a game where two or more players move pieces around a track by rolling a die. The aim of the game is to reach square number sixty-three before any of the other players and avoid obstacles. ([wikipedia](https://en.wikipedia.org/wiki/Game_of_the_Goose))
+
+This kata has been invented by [Matteo Vaccari](https://github.com/xpmatteo), you can find the original slides [here](https://www.slideshare.net/pierodibello/il-dilettevole-giuoco-delloca-coding-dojo).
+
+## General requirements
+- You may use whatever programming language you prefer. Use something that you know well.
+- You should commit your code on GitHub or any other SCM repository you prefer (e.g. bitbucket, gitlab, etc) and send us the link.
+- You should release your work under an OSI-approved open-source license of your choice.
+- You should deliver the sources of your application, with a README that explains how to compile and run it.
+
+**IMPORTANT:** Implement the requirements focusing on writing the best code you can produce.
+
+## Features
+
+### 1. Add players
+As a player, I want to add me to the game so that I can play.
+
+**Scenarios:**
+1. Add Player
+   ```js
+   If there is no participant
+   the user writes: "add player Pippo"
+   the system responds: "players: Pippo"
+   the user writes: "add player Pluto"
+   the system responds: "players: Pippo, Pluto"
+   ```
+
+2. Duplicated Player
+   ```js
+   If there is already a participant "Pippo"
+   the user writes: "add player Pippo"
+   the system responds: "Pippo: already existing player"
+   ```
+
+### 2. Move a player
+As a player, I want to move the marker on the board to make the game progress
+
+**Scenarios:**
+1. Start
+   ```js
+   If there are two participants "Pippo" and "Pluto" on space "Start"
+   the user writes: "move Pippo 4, 2"
+   the system responds: "Pippo rolls 4, 2. Pippo moves from Start to 6"
+   the user writes: "move Pluto 2, 2"
+   the system responds: "Pluto rolls 2, 2. Pluto moves from Start to 4"
+   the user writes: "move Pippo 2, 3"
+   the system responds: "Pippo rolls 2, 3. Pippo moves from 6 to 11"
+   ```
+
+### 3. Win
+As a player, I win the game if I land on space "63"
+
+**Scenarios:**
+1. Victory
+   ```js
+   If there is one participant "Pippo" on space "60"
+   the user writes: "move Pippo 1, 2"
+   the system responds: "Pippo rolls 1, 2. Pippo moves from 60 to 63. Pippo Wins!!"
+   ```
+
+2. Winning with the exact dice shooting
+   ```js
+   If there is one participant "Pippo" on space "60"
+   the user writes: "move Pippo 3, 2"
+   the system responds: "Pippo rolls 3, 2. Pippo moves from 60 to 63. Pippo bounces! Pippo returns to 61"
+   ```
+### 4. The game throws the dice
+As a player, I want the game throws the dice for me to save effort
+
+**Scenarios:**
+1. Dice roll
+   ```js
+   If there is one participant "Pippo" on space "4"
+   assuming that the dice get 1 and 2
+   when the user writes: "move Pippo"
+   the system responds: "Pippo rolls 1, 2. Pippo moves from 4 to 7"
+   ```
+
+### 5. Space "6" is "The Bridge"
+As a player, when I get to the space "The Bridge", I jump to the space "12"
+
+**Scenarios:**
+1. Get to "The Bridge"
+   ```js
+   If there is one participant "Pippo" on space "4"
+   assuming that the dice get 1 and 1
+   when the user writes: "move Pippo"
+   the system responds: "Pippo rolls 1, 1. Pippo moves from 4 to The Bridge. Pippo jumps to 12"
+   ```
+
+### 6. If you land on "The Goose", move again
+As a player, when I get to a space with a picture of "The Goose", I move forward again by the sum of the two dice rolled before
+
+The spaces 5, 9, 14, 18, 23, 27 have a picture of "The Goose"
+
+**Scenarios:**
+1. Single Jump
+   ```js
+   If there is one participant "Pippo" on space "3"
+   assuming that the dice get 1 and 1
+   when the user writes: "move Pippo"
+   the system responds: "Pippo rolls 1, 1. Pippo moves from 3 to 5, The Goose. Pippo moves again and goes to 7"
+   ```
+
+2. Multiple Jump
+   ```js
+   If there is one participant "Pippo" on space "10"
+   assuming that the dice get 2 and 2
+   when the user writes: "move Pippo"
+   the system responds: "Pippo rolls 2, 2. Pippo moves from 10 to 14, The Goose. Pippo moves again and goes to 18, The Goose. Pippo moves again and goes to 22"
+   ```
+
+### 7. Prank (Optional Step)
+As a player, when I land on a space occupied by another player, I send him to my previous position so that the game can be more entertaining.
+
+**Scenarios:**
+1. Prank
+   ```js
+   If there are two participants "Pippo" and "Pluto" respectively on spaces "15" and "17"
+   assuming that the dice get 1 and 1
+   when the user writes: "move Pippo"
+   the system responds: "Pippo rolls 1, 1. Pippo moves from 15 to 17. On 17 there is Pluto, who returns to 15"
+   ```

data/README.md

@@ -0,0 +1,83 @@
+# Table of Contents
+* [Scope](#scope)
+* [Design](#design)
+  * [Cell](#cell)
+  * [Dice](#dice)
+  * [GameBoard](#gameboard)
+  * [Gameplay](#gameplay)
+  * [Player](#player)
+* [Installation](#installation)
+  * [Runtime](#runtime)
+  * [Dependencies](#dependencies)
+  * [Testing](#testing)
+  * [Gem](#gem)
+* [Usage](#usage)
+  * [CLI](#cli)
+  * [Help](help)
+
+# Scope
+This gem is the Ruby implementation of the `Goose Game` code-kata (for more information refer to the [OBJECTIVES](https://github.com/costajob/goose_game/blob/master/OBJECTIVES.md)).
+
+# Design
+The code design follows the single responsibility principle by using a dedicated class/module for any specific task. Each class exposes a minimal public API, when meaningful by using the `call` method, thus behaving like a plain `Proc` object.
+
+## Cell
+The cell of the game board. They are responsible to compute the position of the player and properly display the output messages. Polymorphism is used to reduce conditional logic.
+
+## Dice
+The class represents the two dice used to move players (creating a single Die class brings little benefit to the design). A factory class rolls dice with random values (within 1 to 6), constructor accepts any convertible integers, the absolute value is taken and limited to 6.
+
+## Gameboard
+The board class uses a `Hash` for its data representation: this data structure grants quick access by key. 
+
+## Gameplay
+The main interface with the game core logic is enclosed within the `Gameplay` class: it recognizes input commands, performs actions by creating players, rolling dice and printing appropriate messages to the terminal. The whole game runs within an endless loop.
+
+## Player
+The player of the game, record both current and previous position.
+
+# Installation
+
+## Runtime
+This library supports from `Ruby 2.4.1` on.
+
+## Dependencies
+There are no runtime dependencies, but some developments ones (testing).  
+Just clone the repository, move to the directory and use `bundler`:
+```shell
+bundle install
+```
+
+## Testing
+The code is covered by fast, isolated unit testing.  
+Move to the installation path and run them by:
+```shell
+bundle exec rake
+```
+
+## Gem
+The library is packaged as a `gem`. Build and install it by:
+```shell
+gem build goose_game.gemspec
+...
+gem install --local ./goose_game.gem
+```
+
+# Usage
+
+## CLI
+The gem provides a CLI interface, once installed you will be able to start the game from the terminal:
+```shell
+goose_game
+```
+
+## Help
+The game starts with no prompts, type `help` to see the available commands:
+```shell
+available commands:
+* add player <player_name>
+* move <player_name> 4, 5
+* move <player_name>
+* help
+* exit
+```

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:spec) do |t|
+  t.libs << "spec"
+  t.libs << "lib"
+  t.test_files = FileList["spec/**/*_spec.rb"]
+end
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "goose_game"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/goose_game

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "goose_game"
+
+GooseGame::GamePlay.new.call

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/goose_game.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "goose_game/version"
+
+Gem::Specification.new do |s|
+  s.name = "goose_game"
+  s.version = GooseGame::VERSION
+  s.authors = ["costajob"]
+  s.email = ["costajob@gmail.com"]
+  s.license = "MIT"
+  s.summary = "Implementation of the Goose Game code kata"
+  s.homepage = "https://github.com/costajob/goose_game.git"
+  s.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.bindir = "bin"
+  s.executables << "goose_game" 
+  s.require_paths = ["lib"]
+  s.required_ruby_version = ">= 2.4.1"
+  s.add_development_dependency "bundler", "~> 2.0"
+  s.add_development_dependency "rake", "~> 12.3"
+  s.add_development_dependency "minitest", "~> 5.11"
+end

data/lib/goose_game.rb

@@ -0,0 +1,8 @@
+require "goose_game/gameplay"
+
+module GooseGame
+  extend self
+
+  START = "Start"
+  FINISH = 63
+end

data/lib/goose_game/cell.rb

@@ -0,0 +1,93 @@
+module GooseGame
+  module Cell
+    class Base
+      attr_reader :num, :gameboard
+
+      def initialize(num, gameboard)
+        @num = num.to_i
+        @gameboard = gameboard
+        @tokens = []
+      end
+
+      def call(player, dice)
+        position.tap do |pos|
+          player.move(pos)
+          @tokens.clear
+          @tokens << "#{player} rolls #{dice.d1}, #{dice.d2}"
+          @tokens << "#{player} moves from #{player.prev} to #{dest}"
+        end
+      end
+
+      def to_s
+        @tokens.join(". ")
+      end
+
+      private def position
+        num
+      end
+
+      private def dest
+        num
+      end
+    end
+
+    class Bounce < Base
+      def call(player, dice)
+        super.tap do |pos|
+          @tokens << "#{player} bounces! #{player} returns to #{pos}"
+        end
+      end
+
+      private def position
+        FINISH - num % FINISH
+      end
+
+      private def dest
+        FINISH
+      end
+    end
+
+    class Winning < Base
+      def call(player, dice)
+        super.tap do |pos|
+          @tokens << "#{player} Wins!!"
+        end
+      end
+    end
+
+    class Bridge < Base
+      def call(player, dice)
+        super.tap do |pos|
+          @tokens << "#{player} jumps to #{pos}"
+        end
+      end
+
+      private def position
+        num * 2
+      end
+
+      private def dest
+        "The Bridge"
+      end
+    end
+
+    class Goose < Base
+      def call(player, dice)
+        tokens = []
+        super.tap do |pos|
+          while goose?(pos)
+            pos += dice.to_i
+            tokens << "The Goose. #{player} moves again and goes to #{pos}"
+          end
+          @tokens << tokens.join(", ")
+          player.position = pos
+          return pos
+        end
+      end
+
+      private def goose?(n)
+        gameboard[n].instance_of? Goose
+      end
+    end
+  end
+end

data/lib/goose_game/dice.rb

@@ -0,0 +1,24 @@
+module GooseGame
+  class Dice
+    QTY = 2
+    MAX = 6
+
+    attr_reader :d1, :d2
+
+    def self.roll
+      new(*QTY.times.map { |_| rand(MAX) + 1 })
+    end
+
+    def initialize(d1 = 0, d2 = 0)
+      @d1, @d2 = *check_args(d1, d2)
+    end
+
+    def to_i
+      [d1, d2].sum
+    end
+
+    private def check_args(*args)
+      args.map { |arg| [arg.to_i.abs, MAX].min }
+    end
+  end
+end

data/lib/goose_game/gameboard.rb

@@ -0,0 +1,21 @@
+require "goose_game/cell"
+
+module GooseGame
+  class GameBoard
+    WINNING_CELLS = [63]
+    BRIDGE_CELLS = [6]
+    GOOSE_CELLS = [5, 9, 14, 18, 23, 27]
+
+    def [](n)
+      cells.fetch(n) { Cell::Bounce.new(n, self) }
+    end
+
+    def cells
+      @cells ||= (0..FINISH).reduce({}) { |acc, n| acc[n] = Cell::Base.new(n, self); acc }.tap do |cells|
+        WINNING_CELLS.each { |n| cells[n] = Cell::Winning.new(n, self) }
+        BRIDGE_CELLS.each { |n| cells[n] = Cell::Bridge.new(n, self) }
+        GOOSE_CELLS.each { |n| cells[n] = Cell::Goose.new(n, self) }
+      end
+    end
+  end
+end

data/lib/goose_game/gameplay.rb

@@ -0,0 +1,69 @@
+require "goose_game/dice"
+require "goose_game/gameboard"
+require "goose_game/messages"
+require "goose_game/player"
+
+module GooseGame
+  class GamePlay
+    include Messages
+
+    attr_reader :players, :round_player, :gameboard, :dice
+
+    def initialize(players: [], gameboard: GameBoard.new, output: STDOUT)
+      @players = players
+      @gameboard = gameboard
+      @output = output
+    end
+
+    def call
+      loop do
+        res = play(STDIN.gets)
+        break if res == :exit
+        break if players.any?(&:won?)
+      end
+    end
+
+    private def play(stdin)
+      case stdin.chomp
+      when In::HELP
+        @output.puts Out::HELP
+      when In::PLAYER
+        @output.puts add_player($~[:name])
+      when In::MOVE, In::MOVE_ROLL
+        @dice = (%w[d1 d2] - $~.names).empty? ? Dice.new($~[:d1], $~[:d2]) : Dice.roll
+        @round_player = player($~[:name])
+        @output.puts move($~[:name])
+      when In::EXIT
+        return :exit
+      else
+        @output.puts Out::UNKNOWN
+      end
+    end
+
+    private def add_player(name)
+      existing_player = player(name)
+      return Out::EXISTING.call(existing_player) if existing_player
+      players << Player.new(name)
+      Out::PLAYERS.call(players)
+    end
+
+    private def player(name)
+      players.detect { |p| p.name == name }
+    end
+
+    private def prank_check
+      prank = players.detect { |p| p.name != round_player.name && p.position == round_player.position }
+      return "" unless prank
+      prank.move(round_player.prev)
+      Out::PRANK.call(round_player, prank)
+    end
+
+    private def move(name)
+      return Out::NO_PLAYER.call(name) unless round_player
+      n = round_player.position.to_i + dice.to_i
+      cell = gameboard[n]
+      cell.call(round_player, dice)
+      cell.to_s << prank_check
+    end
+  end
+end

data/lib/goose_game/messages.rb

@@ -0,0 +1,21 @@
+module GooseGame
+  module Messages
+    module In
+      PLAYER    = /add player (?<name>\w+)/i
+      MOVE      = /move (?<name>\w+) (?<d1>\d+), (?<d2>\d+)/i
+      MOVE_ROLL = /move (?<name>\w+)/i
+      HELP      = /help/i
+      EXIT      = /exit/i
+    end
+
+    module Out
+      HELP      = ["available commands:", "* add player <player_name>", "* move <player_name> 4, 5", "* move <player_name>", "* help", "* exit"].join("\n")
+      UNKNOWN   = "can you repeat please?"
+      NO_PLAYER = -> (player) { "#{player}: not an existing player"}
+      PLAYERS   = -> (players) { "players: #{players.join(', ')}" }
+      EXISTING  = -> (player) { "#{player}: already existing player" }
+      ROLL      = -> (player, dice) { "#{player} rolls #{dice.d1}, #{dice.d2}" }
+      PRANK     = -> (player, prank) { ". On #{player.position} there is #{prank}, who returns to #{player.prev}" }
+    end
+  end
+end

data/lib/goose_game/player.rb

@@ -0,0 +1,27 @@
+module GooseGame
+  class Player
+    attr_reader :name
+    attr_accessor :position
+
+    def initialize(name)
+      @name = name
+      @position = START
+      @prev = nil
+    end
+
+    alias_method :to_s, :name
+
+    def move(pos)
+      return if pos == @position
+      @prev, @position = @position, pos.to_i
+    end
+
+    def won?
+      @position == FINISH
+    end
+
+    def prev
+      @prev.to_i.zero? ? START : @prev
+    end
+  end
+end

data/lib/goose_game/version.rb

@@ -0,0 +1,3 @@
+module GooseGame
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: goose_game
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- costajob
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+description: 
+email:
+- costajob@gmail.com
+executables:
+- goose_game
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- OBJECTIVES.md
+- README.md
+- Rakefile
+- bin/console
+- bin/goose_game
+- bin/setup
+- goose_game.gemspec
+- lib/goose_game.rb
+- lib/goose_game/cell.rb
+- lib/goose_game/dice.rb
+- lib/goose_game/gameboard.rb
+- lib/goose_game/gameplay.rb
+- lib/goose_game/messages.rb
+- lib/goose_game/player.rb
+- lib/goose_game/version.rb
+homepage: https://github.com/costajob/goose_game.git
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Implementation of the Goose Game code kata
+test_files: []