chance 0.5.0

data/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+.bundle/
+Gemfile.lock
+pkg/*

data/COPYING

@@ -0,0 +1,19 @@
+#
+# Copyright (c) 2008 Patrick Ewing <patrick.henry.ewing@gmail.com> and Marcel Molina Jr. <marcel@vernix.org>
+# 
+# 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/Gemfile

@@ -0,0 +1,9 @@
+source :rubygems
+
+group :default do
+	gem 'rake'
+end
+
+group :test do
+  gem 'rspec', ">= 1.4.2", :require => 'rspec'
+end

data/README

@@ -0,0 +1,27 @@
+= Chance
+
+Chance is a little Ruby library for expressing uncertainty in your code. Maybe you always wanted to program with probability?
+
+The idea originated with Numeric#percent and Kernel#maybe, which Marcel Molina posted to Projectionist, a tumblelog.  This led to various snippets for executing code in a fuzzier way than usual.  You get such handy, wishy-washy methods as:
+
+Date#at_some_point rather than Date#midnight
+Array#pick(percentage) rather than iterating over every element
+
+"maybe" is a Kernel method that randomly evaluates to true or false when it is called.
+@bob.lucky_winner? = maybe
+# => true
+@chauncey.lucky_winner? = maybe
+# => false
+
+When supplied with a block, it will call it. Or not. Half of the time it just returns nil. For example
+
+maybe {rotate_logs}
+
+By default, maybe is 50/50.  You can also use "probably", "rarely" and "almost_never", or just create your own Chance object like so:
+
+30.percent.chance.of { "rain" }
+
+== Running examples ==
+If you have the bundler gem installed, just run
+
+bundle exec rake

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:lib) do |spec|
+  rules_engine_root = File.expand_path(File.dirname(__FILE__))
+  spec.pattern = rules_engine_root + '/spec/lib/*_spec.rb'
+  spec.rspec_opts = ["--color", "--format", "documentation"]
+  # spec.ruby_opts="-w"
+end
+
+RSpec::Core::RakeTask.new(:examples) do |spec|
+  rules_engine_root = File.expand_path(File.dirname(__FILE__))
+  spec.pattern = rules_engine_root + '/spec/examples/*_spec.rb'
+  spec.rspec_opts = ["--color", "--format", "documentation"]
+  # spec.ruby_opts="-w"
+end
+
+task :default => [:lib, :examples]

data/chance.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "chance/version"
+
+Gem::Specification.new do |s|
+  s.name        = "chance"
+  s.version     = Chance::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Patrick Ewing"]
+  s.email       = ["patrick.henry.ewing@gmail.com"]
+  s.homepage    = "https://github.com/hoverbird/chance"
+  s.summary     = "Programming with probability.  YAGNI certitude."
+  s.description = "Chance is a little Ruby library for expressing uncertainty in your code. Maybe you always wanted to program with probability?"
+
+  s.rubyforge_project = "chance"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+end

data/examples/dice.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + "/../chance")
+
+class Die
+  attr_reader :sides, :odds
+  def initialize(sides)
+    @sides = sides
+    @odds = ((1.0 / sides) * 100 ).percent.chance
+  end
+
+  def self.roll(sides)
+    new(sides).odds.happens?
+  end
+
+  def roll
+    rand(sides).to_i + 1
+  end
+
+  def *(other_die)
+    odds * other_die.odds
+  end
+
+  def to_s
+    odds.to_f
+  end
+end

data/examples/schroedinger.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + "/../chance")
+
+class SchroedingerCat
+  def initialize
+    @alive = nil
+  end
+  def alive?
+    @alive ||= maybe
+  end
+end
+
+# @zombie_cat = SchroedingerCat.new
+# puts "The cat is #{ "undead" if @zombie_cat.instance_variable_get(:@alive).nil? } inside the box. We just don't know its state. Let's check."
+# puts "Oh em gee. The cat is #{@zombie_cat.alive ? 'alive' : 'dead' }!!"
+# puts "I wonder if itwas #{@zombie_cat.alive ? 'frisky and impatient' : 'slowly decomposing' } this whole time."

data/examples/weather.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + "/../chance")
+
+def rain
+   "'|'|'|'|'|'|'|'"
+end
+
+def snow
+   ".*.*.*.*.*.*.*."
+end
+#
+# 24.times do |hour|
+#   weather = [ 60.percent.chance.of {rain}, 10.percent.chance.of {snow} ]
+#   puts [ hour, weather ].join(' ')
+# endfdf

data/lib/chance.rb

@@ -0,0 +1,2 @@
+chance_lib_dir = File.expand_path(File.dirname(__FILE__)) + "/chance/"
+['core_extensions', 'percentage', 'chance', 'chance_case'].each {|filename| require chance_lib_dir + filename}

data/lib/chance/chance.rb

@@ -0,0 +1,67 @@
+class Chance
+  attr_reader :odds, :happens, :event
+  alias :happens? :happens
+  include Comparable
+
+  def self.case(*chances)
+    raise "Chances don't add to 100" unless chances.inject(0) {|sum, chance| sum + chance.to_f } == 100
+    ranges = []
+    chances = chances.sort_by{|c| c.to_f}
+    chances.each_with_index do |chance, i|
+      chance = chance.to_f
+      range =
+        if i == 0
+          0..chance
+        elsif i == chances.size - 1
+          @last_chance..100
+        elsif @last_chance
+          @last_chance..chance
+        end
+      @last_chance = range.begin
+      ranges << range
+    end
+    num = Kernel.rand(100)
+    ranges.each_with_index do |r, i|
+      if r.include? num
+        return chances[i].event.call
+      end
+    end
+  end
+
+  def initialize(percent)
+    @odds = percent
+    @happens = @odds.to_f > Kernel.rand(100)
+  end
+
+  def of(&block)
+    yield if happens?
+  end
+
+  def will(&block)
+    @event = block
+    self
+  end
+
+  def to_f
+    odds.to_f
+  end
+  alias :value :to_f
+
+  def to_s
+    "A #{odds.to_f} percent chance"
+  end
+
+  def *(other_chance)
+    Chance.new(self.odds.of(chance.odds.to_f))
+  end
+
+  def <=>(other_chance)
+    odds.to_f <=> other_chance.to_f
+  end
+
+  def identical(other_chance)
+    self == other_chance && self.happens? == other.happens?
+  end
+  alias :identical? :identical
+
+end

data/lib/chance/chance_case.rb

@@ -0,0 +1,19 @@
+class ChanceCase
+  attr_reader :outcome
+
+  def self.test(&block)
+  	puts 'Here goes:'
+  	case block.arity
+  		when 0
+  			yield
+  		when 1
+  			yield 'one'
+  		when 2
+  			yield 'one', 'two'
+  		when 3
+  			yield 'one', 'two', 'three'
+  	end
+  	puts 'Done!'
+  end
+
+end

data/lib/chance/core_extensions.rb

@@ -0,0 +1,65 @@
+module Kernel
+
+  def maybe(percent = 50.percent, &block)
+    if block_given?
+      percent.chance.of &block
+    else
+      percent.chance.happens?
+    end
+  end
+
+end
+
+class Numeric
+  def percent
+    Percentage.new(self)
+  end
+
+  def reduce_by(percentage = 50.percent, &block)
+    block ||= Proc.new {|number| number.small?}
+    return self if block.call(self)
+    reduced_to = self
+    until block.call(reduced_to)
+      reduced_to = reduced_to.reduce_to(percentage)
+    end
+    Integer(reduced_to)
+  end
+  alias_method :reduce, :reduce_by
+end
+
+class String
+  def odds
+    raise ArgumentError.new "You must express odds like 2:1 or 2-1" unless match /^[0-9]+(:|-)[0-9]+$/
+    first, second = *split($1).map {|string| string.to_f}
+    Percentage.new((second / first) * 100)
+  end
+end
+#
+# class Date
+#   def at_some_point
+#     (at_midnight..tomorrow.at_midnight).to_a.rand
+#   end
+#   alias :whenever :at_some_point
+# end
+
+class Array
+  def random
+    self[rand(length)]
+  end
+
+  def pick(percent)
+    picks, percentage = [], percent.of(length).round
+    while picks.length < percentage
+      picks << random
+      picks.uniq!
+    end
+    picks
+  end
+
+  def pick_about(percentage)
+    select do |element|
+      percentage.chance.happens?
+    end
+  end
+
+end

data/lib/chance/percentage.rb

@@ -0,0 +1,35 @@
+class Percentage
+  include Comparable
+
+  attr_reader :value
+
+  def initialize(value)
+    @value = value
+  end
+
+  def of(number_or_percentage)
+    number_or_percentage * (value / 100.0)
+  end
+
+  def chance
+    Chance.new self
+  end
+
+  def to_f
+    @value.to_f
+  end
+
+  def to_s
+    to_f.to_s
+  end
+
+  def <=>(other)
+    value <=> other.value
+  end
+
+  def *(other)
+    other_value = other.kind_of?(Numeric) ? other : other.value
+    Percentage.new value * other_value
+  end
+
+end

data/lib/chance/version.rb

@@ -0,0 +1,3 @@
+module Chance
+  VERSION = "0.5.0"
+end

data/spec/examples/dice_spec.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Die do
+  it "outputs a result when rolled for a given number of sides" do
+    @d6 = Die.new(6)
+    (1..6).should include(@d6.roll)
+  end
+end

data/spec/lib/chance_spec.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Chance do
+  before do
+    @chance = 50.percent.chance
+    @second_chance = 50.percent.chance
+    @good_chance = 90.percent.chance
+    @fat_chance = 10.percent.chance # include Sarcasm
+  end
+
+  it "can be created from a Percentage" do
+    Percentage.new(20).chance.should be_kind_of Chance
+  end
+
+  it "has #odds expressed as a Percentage" do
+    @chance.odds.should be_kind_of Percentage
+  end
+
+  it "should be comparable with another Chance" do
+    @chance.should be > @fat_chance
+    @chance.should be == @second_chance
+    @chance.should be < @good_chance
+  end
+
+  context "case statement" do
+    it "renders a single outcome" do
+      outcome = Chance.case(
+        70.percent.chance.will {'snow'},
+        20.percent.chance.will {'sleet'},
+        8.percent.chance.will {'sun'},
+        2.percent.chance.will {'knives'}
+      )
+      %w(sun sleet snow knives).should include(outcome)
+    end
+
+    it "generally evaluates to the expected outcome with stacked odds" do
+      outcome = Chance.case(
+        0.01.percent.chance.will {'rain'},
+        99.99.percent.chance.will {'sleet'}
+      )
+      outcome.should == 'sleet'
+    end
+
+    it "only fires a single case block" do
+      @count = 0
+      outcome = Chance.case(
+        50.percent.chance.will {@count += 1},
+        50.percent.chance.will {@count += 1}
+      )
+      @count.should be 1
+    end
+
+    it "generally follows expected probabilities" do
+      @heads, @tails = 0, 0
+      10_000.times do
+        Chance.case(
+          50.percent.chance.will {@tails += 1},
+          50.percent.chance.will {@heads += 1}
+        )
+      end
+      10_000.should == @heads + @tails
+      (10_000 / 2 - @heads).abs.should be < 200
+    end
+
+    it "should raise if odds add to less than 100" do
+      lambda {
+        Chance.case(
+          10.percent.chance.will {'rain'},
+          20.percent.chance.will {'sleet'}
+        )
+      }.should raise_error
+    end
+
+    it "should raise if odds add to more than 100" do
+      lambda {
+        Chance.case(
+          10.percent.chance.will {'rain'},
+          20.percent.chance.will {'sleet'},
+          90.percent.chance.will {'sleet'}
+        )
+      }.should raise_error
+    end
+  end
+
+end

data/spec/lib/core_extensions_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Extensions to core classes;" do
+
+  context "Kernel" do
+    describe "maybe" do
+      it "returns true or false when called with no args" do
+        [true, false].should include maybe
+      end
+
+      it "executes a block of code half the time it's passed in" do
+        @times_called = 0
+        1000.times do
+          maybe do
+            @times_called += 1
+          end
+        end
+
+        @times_called.should be > 1, "Odds are 1 in 1000 this fails"
+        @times_called.should be < 1000, "Odds are 1 in 1000 this fails"
+      end
+    end
+
+  end
+
+  context "Numeric" do
+    it "adds a #percent method to Numerics, returning Percentage" do
+      20.percent.should == Percentage.new(20)
+      20.0.percent.should == Percentage.new(20)
+    end
+
+    it "percentages work as expected" do
+      50.percent.of(20).should == 10
+    end
+
+  end
+
+  context "String" do
+    describe "#odds" do
+      it "splits a string on :, returning a Percentage" do
+        "100:1".odds.should == 1.percent
+      end
+
+      it "splits a string on -, returning a Percentage" do
+        "2-1".odds.should == 50.percent
+      end
+
+      it "raises an ArgumentError when not correctly delimited" do
+        message = /You must express odds like 2:1 or 2-1/
+        lambda {"2 to 1".odds}.should raise_error(ArgumentError, message)
+        lambda {"2,1".odds}.should raise_error(ArgumentError, message)
+        lambda {"2:1:2".odds}.should raise_error(ArgumentError, message)
+      end
+    end
+
+  end
+
+  context "Array" do
+    describe "#random" do
+      it "returns a randomly selected element" do
+        a = [1,2,3]
+        a.should include(a.random)
+      end
+    end
+
+  end
+end

data/spec/lib/percentage_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Percentage do
+  it "can be created from an Integer" do
+    20.should == Percentage.new(20).value
+  end
+
+  it "can be created from a Float" do
+    20.0.should == Percentage.new(20.0).value
+  end
+
+  it "is comparable to other Percentages" do
+    Percentage.new(20).should == Percentage.new(20)
+    Percentage.new(10).should be < Percentage.new(15)
+    Percentage.new(15).should be > Percentage.new(10)
+  end
+
+  it "can get a Percentage of a number" do
+    result = 50.percent.of 50
+    result.should == 25
+  end
+
+  it "can get a Percentage of a Percentage" do
+    result = 25.percent.of 90.percent
+    result.should == 22.5.percent
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'bundler'
+Bundler.require(:default, :examples)
+
+require 'rspec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib', 'chance'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'examples'))
+
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'..', 'lib', 'chance', '**', '*.rb'))].each {|f| require f }
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'..', 'examples', '**', '*.rb'))].each {|f| require f }

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: chance
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Patrick Ewing
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-13 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Chance is a little Ruby library for expressing uncertainty in your code. Maybe you always wanted to program with probability?
+email: 
+- patrick.henry.ewing@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- COPYING
+- Gemfile
+- README
+- Rakefile
+- chance.gemspec
+- examples/dice.rb
+- examples/schroedinger.rb
+- examples/weather.rb
+- lib/chance.rb
+- lib/chance/chance.rb
+- lib/chance/chance_case.rb
+- lib/chance/core_extensions.rb
+- lib/chance/percentage.rb
+- lib/chance/version.rb
+- spec/examples/dice_spec.rb
+- spec/lib/chance_spec.rb
+- spec/lib/core_extensions_spec.rb
+- spec/lib/percentage_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/hoverbird/chance
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: chance
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Programming with probability.  YAGNI certitude.
+test_files: 
+- spec/examples/dice_spec.rb
+- spec/lib/chance_spec.rb
+- spec/lib/core_extensions_spec.rb
+- spec/lib/percentage_spec.rb
+- spec/spec_helper.rb