functional-yahtzee 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ee9515ae7d6e62b2c338eaa390b462f0a00fd47f
+  data.tar.gz: 41387d21afb1951765a3d9c8cf5aee97ada9ec8a
+SHA512:
+  metadata.gz: 763b40ce6d6b310e281eb5b8ad5c56f50827c06048576d6313f2c3ffb836c480c5c7fa869cdb74e76b3450c1e52222c2851330ae0217c8cd9db296c8d849074b
+  data.tar.gz: 806e1457646e3748eb377893e0f34b55c38fecc7fa9b351aa8905e4c31efee611124ad191efa19533231116de11eecc89aa6bd62e9254a1e9ad592058f32ead2

data/.bundle/config

@@ -0,0 +1 @@
+--- {}

data/.gitignore

@@ -0,0 +1,2 @@
+coverage
+*.gem

data/.ruby-version

@@ -0,0 +1 @@
+2.1.0-dev

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3
+notifications:
+  email: false

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,71 @@
+PATH
+  remote: .
+  specs:
+    functional-yahtzee (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    celluloid (0.15.2)
+      timers (~> 1.1.0)
+    coderay (1.1.0)
+    coveralls (0.7.0)
+      multi_json (~> 1.3)
+      rest-client
+      simplecov (>= 0.7)
+      term-ansicolor
+      thor
+    docile (1.1.0)
+    ffi (1.9.3)
+    formatador (0.2.4)
+    guard (2.2.3)
+      formatador (>= 0.2.4)
+      listen (~> 2.1)
+      lumberjack (~> 1.0)
+      pry (>= 0.9.12)
+      thor (>= 0.18.1)
+    guard-minitest (2.0.0)
+      guard (~> 2.0)
+      minitest (>= 3.0)
+    listen (2.2.0)
+      celluloid (>= 0.15.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lockfile (2.1.0)
+    lumberjack (1.0.4)
+    method_source (0.8.2)
+    mime-types (2.0)
+    minitest (5.0.8)
+    multi_json (1.8.2)
+    pry (0.9.12.3)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rake (10.1.0)
+    rb-fsevent (0.9.3)
+    rb-inotify (0.9.2)
+      ffi (>= 0.5.0)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+    simplecov (0.8.1)
+      docile (~> 1.1.0)
+      lockfile (>= 2.1.0)
+      multi_json
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    slop (3.4.7)
+    term-ansicolor (1.2.2)
+      tins (~> 0.8)
+    thor (0.18.1)
+    timers (1.1.0)
+    tins (0.13.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  coveralls (~> 0.7)
+  functional-yahtzee!
+  guard-minitest (~> 2.0)
+  rake (~> 10.1)

data/Guardfile

@@ -0,0 +1,6 @@
+# Units
+guard :minitest do
+  watch(%r{^test/(.*)\/?(.*)_test\.rb})
+  watch(%r{^lib/(.*/)?([^/]+)\.rb})     { |m| "test/unit/#{m[1]}#{m[2]}_test.rb" }
+  watch(%r{^test/test_helper\.rb})      { 'test' }
+end

data/README.md

@@ -0,0 +1,115 @@
+# Functional Yahztee in RUBY
+
+The goal of this project is to build the dice game Yahtzee in a functional, concise, testable manner. The code within is
+highly opinionated, and is ahallmark of my style. This is my perfect world where code and beauty collide.
+
+If you are like me, and I know I am... you have something to learn from this code here. This is how you write clean, decoupled, testable, functional ruby code.
+
+Expect a series of screencasts discussing the choices I have made here to get the results I ended up with.
+
+[rubyquiz #19](http://rubyquiz.com/quiz19.html) proposed this
+problem, and a very imperative solution was provided by James
+Edward Gray II, one my ruby heros. I doubt he would write this the same way could he revisit the problem.
+
+This is my contribution to the same problem, with the additional task of being as functional as possible and downright pretty code.
+
+## Ruby is dead
+
+1.8 was the Ruby of your Father. It was for a world with single cores and CPUs growing at a predictable rate each year. Ruby 1.8 is dead....
+
+## Long Live Ruby
+
+Thankfully the teams behind Rubinius, JRuby, and even MRI have been
+working on this problem. I am happy to say that Ruby 2.0+ is
+perfectly suited as a stepping stone to get you into the new
+world, a world where CPU matters not, and cores own.
+
+## Requirements
+
+This is being developed in Ruby 2.1 with CI running on 2.0 and 1.9.3. My style tends to stay away from external dependencies whenever I can. (read: I am not afraid to code what I need)
+
+I haven't gemmified this as of yet, so a clone and bundle with ruby
+1.9.3+ and you can run the tests. I would love to get this running on rubinius as well.
+
+```bash
+cd <cloned_path>
+rake
+```
+
+## Usage
+
+```ruby
+score_card = ScoreCard.new    
+writer     = ScoreCard.persist(score_card)
+
+Round.new do
+  roll1 = first_roll             # => [1,2,3,5,5]
+  roll2 = second_roll([1,2,3,5]) # => [1,2,3,5,3]
+  roll3 = third_roll([1,2,3,5])  # => [1,2,3,5,4]
+
+  score_card = Scoring.score(roll3, :large_straight, &writer)
+end
+
+Round.new do
+  roll1 = first_roll             # => [1,1,3,5,5]
+  roll2 = second_roll([1,1,5,5]) # => [1,1,5,5,1]
+
+  score_card = Scoring.score(roll2, :full_house, &writer)
+end
+
+# ...
+
+upper_scores = score_card.to_hash.select do |k,_| 
+  ScoreCard.upper_keys.include? k
+end
+score_card = Scoring.score_upper_total(upper_scores, &writer)
+
+lower_scores = score_card.to_hash.select do |k,_| 
+  ScoreCard.lower_keys.include? k
+end
+
+upper_total = score_card.upper_total
+game_scores = lower_scores.merge(upper_total: upper_total)
+score_card  = Scoring.score_game_total(game_scores, &writer)
+
+puts "Grand total: #{score_card.game_total}"
+
+```
+
+## Contributions
+
+I am not accepting contributions at this time, this is my showcase code. This is my own highly opinionated software, inspired by all those listed in the section below *Many Thanks*.
+
+## Many Thanks
+
+I would like to say thank you to all the people I have sucked off of like a vampiric zombie since 2007. Some of these were from videos of talks, some were pairing sessions, some were just friends on irc who liked to bang Ruby.
+
+* James Edward Gray II
+* Josh Susser
+* Ben Curtis
+* Avdi Grimm
+* Zed
+* Gregg Pollack
+* Daniel Fischer
+* Jose Valim
+* Aaron Patterson
+* Corey Haines
+* Ryan Bates
+* Steve Klabnik
+* Brian Guthrie
+* Fabio Akita
+* Rick Olsen
+* Obie Fernandez
+* Sandi Metz
+* Phil Cohen
+* Jessica Kerr
+
+Whew.. Sorry if I missed you!
+
+## Health
+
+* My code can beat your code up
+
+[![Build
+Status](https://travis-ci.org/dreamr/functional_yahtzee.png)](https://travis-ci.org/dreamr/functional_yahtzee)
+[![Coverage Status](https://coveralls.io/repos/dreamr/functional_yahtzee/badge.png?branch=master)](https://coveralls.io/r/dreamr/functional_yahtzee?branch=master) [![CodeClimate Grade](https://codeclimate.com/github/dreamr/functional_yahtzee.png)](https://codeclimate.com/github/dreamr/functional_yahtzee/code)

data/Rakefile

@@ -0,0 +1,13 @@
+require 'rake/testtask'
+
+desc "Open a console with the basic libs loaded"
+task :console do
+  sh "irb -rubygems -Ilib -r game.rb"
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*_test.rb']
+  t.libs = ["lib", "test"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+lib = File.expand_path("../../lib",__FILE__)
+$:.unshift lib
+
+module Yahtzee
+  require 'game'
+
+  module_function
+
+  def repl
+    -> prompt do
+      print prompt
+      handle_input(gets.chomp!)
+    end
+  end
+
+  def handle_input(input)
+    begin
+      result = eval(input)
+    rescue Exception => e
+      result = e.message
+    end
+    puts result.to_s
+  end
+end
+
+loop do
+  Yahtzee.repl[">> "]
+end
+

data/functional_yahtzee.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'yahtzee'
+
+Gem::Specification.new do |spec|
+  spec.name          = "functional-yahtzee"
+  spec.version       = Yahtzee::VERSION
+  spec.authors       = ["Dreamr"]
+  spec.email         = ["dreamr.okelly@gmail.com"]
+  spec.description   = %q{Functional yahtzee}
+  spec.summary       = %q{Yahztee in functional ruby}
+  spec.homepage      = "http://github.com/dreamr/functional_yahtzee"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_development_dependency "bundler",        "~> 1.3"
+  spec.add_development_dependency "rake",           "~> 10.1"
+  spec.add_development_dependency "guard-minitest", "~> 2.0"
+  spec.add_development_dependency "coveralls",      "~> 0.7"
+end

data/lib/dice.rb

@@ -0,0 +1,19 @@
+require_relative 'yahtzee'
+
+# Yahtzee::Dice is just a dice dsl for yahtzee
+module Yahtzee::Dice
+  DIE_FACES = 6
+  MAX_DIE_COUNT = 5
+  
+  def self.roll(num)
+    limit = num > MAX_DIE_COUNT ? MAX_DIE_COUNT : num
+    1.upto(limit).map {|die| rand(1..DIE_FACES) }
+  end
+
+  def self.reroll(keepers)
+    new_roll = keepers + roll(MAX_DIE_COUNT-keepers.count)
+    new_roll[0..(MAX_DIE_COUNT-1)]
+  end
+end
+
+

data/lib/errors.rb

@@ -0,0 +1,5 @@
+module Yahtzee
+  module Errors
+    class NotAScoreboardPlacementError < Exception; end
+  end
+end

data/lib/game.rb

@@ -0,0 +1,33 @@
+require 'yahtzee'
+require 'dice'
+require 'round'
+require 'scoring'
+
+# This module is the imperative shell of sorts. It provides
+# the 'DSL' of the Yahtzee library and is mostly a wrapper
+# for internals, 'gluing' the application together from a
+# bunch of functions into a cohesive playable game.
+#
+module Yahtzee
+  module Game
+    include Yahtzee::Errors
+    include Yahtzee::Scoring
+    include Yahtzee::Dice
+
+    module_function
+
+    def first_roll
+      Dice.roll(5)
+    end
+
+    def second_roll(keepers)
+      Dice.reroll(keepers)
+    end
+    # tricky - todo: alias_method :third_roll, :second_roll
+    
+    def third_roll(keepers)
+      Dice.reroll(keepers)
+    end
+
+  end
+end

data/lib/probability.rb

@@ -0,0 +1,32 @@
+require 'yahtzee'
+require 'dice'
+
+# I will need some kind of UI, Yahtzee::Probability aids in
+# the decisions an AI will have to make based on their score
+# card, the dice, and the probability vs possible score
+module Yahtzee::Probability
+  module_function
+
+  def small_straight(dice, rolls_left)
+    possibilities = dice.sort.each_cons(3).select do |a,b,c| 
+      a+1==b && b+1==c
+    end.flatten
+    straight_possibility_from(dice, possibilities, rolls_left)
+  end
+
+  def large_straight(dice, rolls_left)
+    possibilities = dice.sort.each_cons(4).select do |a,b,c,d| 
+      a+1==b && b+1==c && c+1==d
+    end.flatten
+    straight_possibility_from(dice, possibilities, rolls_left)
+  end
+
+private
+
+  def self.straight_possibility_from(dice, possibilities, rolls_left)
+    dice_left = (dice-possibilities).count
+    possible_faces = dice_left*Yahtzee::Dice::DIE_FACES
+    rolls_left.to_f/possible_faces.to_f
+  end
+
+end

data/lib/round.rb

@@ -0,0 +1,11 @@
+require 'yahtzee'
+
+module Yahtzee
+  class Round
+
+    def initialize(&block)
+      block.call
+    end
+
+  end
+end

data/lib/score_card.rb

@@ -0,0 +1,59 @@
+require 'yahtzee'
+
+# Immutable via API, I will work on freezing this later,
+# but notice that when you 'save' you are not altering
+# THIS instance, you return a new instance with the old 
+# and the new attributes
+module Yahtzee
+  SCORINGS = [:aces, :twos, :threes, 
+              :fours, :fives, :sixes,
+              :upper_subtotal, :upper_total,
+              :small_straight, :large_straight, 
+              :full_house, :three_of_a_kind, :four_of_a_kind,
+              :yahtzee, :chance, :bonus_yahtzee_1,
+              :bonus_yahtzee_2, :bonus_yahtzee_3,
+              :lower_subtotal, :game_total]
+
+  class ScoreCard < Struct.new(*SCORINGS)
+    def initialize(attrs={})
+      super *attrs.values_at(*self.class.members)
+    end
+
+    def to_hash
+      Yahtzee::SCORINGS.reduce({}) do |hash, attr|
+        hash.merge(attr => send(attr))
+      end
+    end
+
+    def self.upper_keys
+      [:aces, :twos, :threes, :fours, :fives, :sixes]
+    end
+
+    def self.lower_keys
+      [:yahtzee, :bonus_yahtzee_1, :bonus_yahtzee_2, 
+       :bonus_yahtzee_3, :three_of_a_kind,
+       :four_of_a_kind, :full_house, :small_straight,
+       :large_straight, :chance]
+    end
+
+
+    def self.persist(score_card)
+      ->(placement, value) {
+        old_values = score_card.to_hash
+        new_values = { placement => value }
+        score_card = new(old_values.merge(new_values))
+      }
+    end
+
+    def self.placement_keys
+      Yahtzee::SCORINGS - meta_keys
+    end
+
+    def self.meta_keys
+      [:bonus_yahtzee_1, :bonus_yahtzee_2,
+       :bonus_yahtzee_3, :upper_subtotal,
+       :upper_total,     :lower_subtotal,
+       :game_total] 
+    end
+  end
+end