minigame 0.0.1 → 0.0.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YWY0MTkxZDc2ZTg1NWExMTgwODMyMDAwNjEwNmQ3YzZiODJmYTM1Zg==
+    OWQ1MjQwNjNjNGM5MTZiNWQ2ZDE3ZjQ4YWUxYmZmZjMyM2QxY2NmNA==
   data.tar.gz: !binary |-
-    NGYzYTBiYTQ0ODFkNDg5OWVlYWRiZDJmYTJjNDIyNzZlY2VmNzk3Yw==
+    ZjMyNjg1N2ZjYjY0ODI1YmY5ZTdhMDA1NzkxM2Y5OWRhOGIxMThhMA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    OTM4MDgzZGY3MWNlNWUwOWY0ZGE0ZmM2ZDg4NWQ0NmQxNzU0YTc2Y2JiNWQy
-    MWMzMTA3MmY5MDk1Mjk0ZjVjMGNkODNlYTU0OGU2ZjJlMGYzYTdjYTBmOWE3
-    NTA2OWMzMDhhNGU2OGFmYjFhNzA5ZGJiNjVjZGMyODg2MThiYTg=
+    YzBlNDY5ODdkZTdlMTRjNzExYTNhMjVlZGViYzQxMDZlNzdkNDMyODQyNzhk
+    Y2RiMzA0NGU4OGM1M2IxMzY5YmM5ZGQ1MTJhNDQyMTYyMzJiNjUwYzYxYzVi
+    NzljNDg0NzQ1OTg5ZjAxNzhjZDc2MTg1NGRlZWYyODI1Y2E4MjQ=
   data.tar.gz: !binary |-
-    YjhlN2JiMzQzMjRmZDBmOGFjODQyMjA5Nzk5ZjRkZDAwZGYyN2Y4NGM3YjQ4
-    ZjZhM2NjMWI4YmNlNWQwZjc3OTVkMDk3ZDQwODhiNGJjNmVhMzc4YWUxNjI1
-    ZWJhZjk5YTNmMzUyMWMyMzUwYWNkY2ZiYTNjMzgzNzk1Y2RjNzA=
+    YjcyMmE3MjUyYzg0MDM5NGQyZWNmYmY4NDdjNjllYzdmZmI4YTYwNWYxZmM0
+    ODE4Mjk2Y2YwMTg5MmRiNzEzM2YzMjgyNGUzZjM1NzdlMDFhZjRmMWMzZjNm
+    YmYyMDM4NDY1MjZjNjRhNjYxMDJiY2ZjNWJlMGE4MDk0ZmFiMjM=

data/.gitignore

@@ -91,6 +91,8 @@ capybara-*.html
 /log/*
 /tmp/*
 /db/*.sqlite3
+/pkg
+/pkg/*
 /public/system/*
 /coverage/
 /spec/tmp/*

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - "1.9.3"
+# uncomment this line if your project needs to run something other than `rake`:
+# script: bundle exec rspec spec

data/Gemfile

@@ -2,4 +2,4 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in minigame.gemspec
 gemspec
-gem 'debugger'
+#gem 'debugger'

data/Gemfile.lock

@@ -1,27 +1,29 @@
 PATH
   remote: .
   specs:
-    minigame (0.0.1)
+    minigame (0.0.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    columnize (0.3.6)
-    debugger (1.6.1)
-      columnize (>= 0.3.1)
-      debugger-linecache (~> 1.2.0)
-      debugger-ruby_core_source (~> 1.2.3)
-    debugger-linecache (1.2.0)
-    debugger-ruby_core_source (1.2.3)
+    diff-lcs (1.2.4)
     minitest (5.0.6)
     rake (10.1.0)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   bundler (~> 1.3)
-  debugger
   minigame!
   minitest
   rake
+  rspec

data/README.md

@@ -1,6 +1,12 @@
+[![Build Status](https://travis-ci.org/wavell/minigame.png)](https://travis-ci.org/wavell/minigame)
 # MiniGame
 ## Simplistic Game Theory Library in Ruby
 
+Installation
+```
+gem install minigame
+```
+
 Usage:
 
 To create new players:
@@ -70,7 +76,7 @@ To get the list a weakly dominated strategies:
 #   ------------------------|---------------------|------------------
 gs.weakly_dominated_list
 
-  [{:name=>"Generic Training"}, {:name=>"Deny Training"}]
+  [{:name=>"Generic Training"}]
 
 ```
 

data/Rakefile

@@ -2,6 +2,7 @@ require "bundler/gem_tasks"
 require 'rake/testtask'
 Rake::TestTask.new do |t|
   t.libs << 'test'
+  system("bundle exec rspec spec/")
 end
 
 desc "Run tests"

data/lib/minigame/gameable.rb

@@ -79,7 +79,10 @@ module Gameable
         end
       end
     end
-    dominated_list.flatten.uniq
+    dom = dominated_list.flatten.uniq
+    strict = strictly_dominated_list
+    weakly_dominated_list = dom.take_while{|i| strict.include?(i)==false}
+    weakly_dominated_list
   end
 
   def strategies_by_player(player)

data/lib/minigame/version.rb

@@ -1,3 +1,3 @@
 module Minigame
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/minigame.gemspec

@@ -6,11 +6,11 @@ require 'minigame/version'
 Gem::Specification.new do |spec|
   spec.name          = "minigame"
   spec.version       = Minigame::VERSION
-  spec.authors       = ["Wavell Watson"]
-  spec.email         = ["wavell.watson@gmail.com"]
+  spec.authors       = ["W Watson"]
+  spec.email         = ["me@wwatson.me"]
   spec.description   = %q{A game theory library}
   spec.summary       = %q{A minimalistic game theory library that computes nash equilibrium}
-  spec.homepage      = ""
+  spec.homepage      = "https://github.com/wavell/minigame"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
@@ -21,5 +21,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest"
+  spec.add_development_dependency "rspec"
   
 end

data/spec/models/array_of_hashes_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe ArrayOfHashes do
+  before(:each) do
+    class TestAOfH
+      include ArrayOfHashes
+    end
+  end
+
+  it "should instantiate with an array of hashes" do
+    aoh = TestAOfH.new [{keyname1: "test1", keyname2: "test2"},{keyname3: "test3", keyname4: "test4"}]
+    aoh.count.should == 2
+  end
+
+  it "should have enumerable functions" do
+    aoh = TestAOfH.new [{keyname1: "test1", keyname2: "test2"},{keyname3: "test3", keyname4: "test4"}]
+    @test2 = aoh.select{|x| x[:keyname2] == "test2"}
+    @test2.count.should == 1
+  end
+
+  it ".required_keys should reject non-symbols" do
+    aoh=TestAOfH.new
+    expect {
+      aoh.required_keys ["name", "description"]
+    }.to raise_error(RuntimeError,/Not a symbol/)
+  end
+
+  it ".required_keys should work as assignment" do
+    aoh=TestAOfH.new
+    expect {
+      aoh.required_keys = [:name, :description]
+    }.to_not raise_error
+  end
+
+  it ".required_keys should also work with a single symbol (not an array)" do
+    aoh=TestAOfH.new
+    expect {
+      aoh.required_keys = :name
+    }.to_not raise_error
+  end
+
+  it ".required_keys should accept a list of symbols" do
+    aoh=TestAOfH.new
+    expect {
+      aoh.required_keys([:name, :description])
+    }.to_not raise_error
+  end
+
+  it ".check_keys should allow a name" do
+    aoh=TestAOfH.new
+    expect {
+      aoh.check_keys({name: "Deny Training"})
+    }.to_not raise_error
+  end
+
+  it ".check_keys should raise an error if not passed a hash" do
+    aoh=TestAOfH.new
+    expect {
+      aoh.check_keys('notahash')
+    }.to raise_error(RuntimeError,/Not a Hash/)
+  end
+
+  it ".check_keys should check for name" do
+    aoh=TestAOfH.new
+    aoh.required_keys :name
+    expect {
+      aoh.check_keys({hmm: 'notahash'})
+    }.to raise_error(RuntimeError,/Name required/)
+  end
+
+  it "should allow addition of hashes with <<" do
+    aoh = TestAOfH.new 
+    aoh << {keyname1: "test1", keyname2: "test2"}
+    aoh << {keyname3: "test3", keyname4: "test4"}
+    aoh.count.should == 2
+  end
+
+  it "should check for an required keys when initializing" do
+    aoh = TestAOfH.new 
+    aoh.required_keys = [:name, :description]
+    expect {
+      aoh << {notname: "test1", description: "test2"}
+    }.to raise_error(RuntimeError,/Name required/)
+  end
+
+  it "should allow inserts when required keys are present" do
+    aoh = TestAOfH.new 
+    aoh.required_keys = [:name, :description]
+    expect {
+      aoh << {name: "test1", description: "test2"}
+      aoh << {name: "test3", description: "test4"}
+    }.to_not raise_error
+  end
+end

data/spec/models/gameable_spec.rb

@@ -0,0 +1,4 @@
+describe Gameable do
+  it "should create a game on another entity" do
+  end
+end

data/spec/models/games_spec.rb

@@ -0,0 +1,280 @@
+require 'spec_helper'
+
+describe Game do
+
+  # training game -- generic weakly dominated (not realistic)
+  # 
+  #      Employer:            | Task Specific       |    Generic
+  # You:     -----------------|---------------------|------------------
+  #                           |                     |
+  #   Deny Training           |  (-2, -1)           |     (-2, -1)
+  #   ------------------------|---------------------|------------------
+  #   Accept Training         |  (1, 4)             |     (5, -2)
+  #   ------------------------|---------------------|------------------
+  def game_with_weakly_dominated_strategies
+    strategies = Strategy.new [{name: "Accept Training"}, {name: "Generic Training"},{name: "Task Specific Training"},{name: "Deny Training"}]
+    accept = strategies.find{|x| x[:name] == "Accept Training"}
+    generic = strategies.find{|x| x[:name] == "Generic Training"}
+    task = strategies.find{|x| x[:name] == "Task Specific Training"}
+    deny = strategies.find{|x| x[:name] == "Deny Training"}
+    employer = Player.new name: "IBM"
+    employee = Player.new name: "John Smith"
+
+    strategy_profile = StrategyProfile.new
+    strategy_profile << {id: 1, strategy: generic, payoff: -2, player: employer}
+    strategy_profile << {id: 1, strategy: accept, payoff: 5, player: employee}
+
+    strategy_profile << {id: 2, strategy: generic, payoff: -1, player: employer}
+    strategy_profile << {id: 2, strategy: deny, payoff: -2, player: employee}
+
+    # not realistic
+    strategy_profile << {id: 3, strategy: task, payoff: -1, player: employer}
+    strategy_profile << {id: 3, strategy: deny, payoff: -2, player: employee}
+
+    strategy_profile << {id: 4, strategy: task, payoff: 4, player: employer}
+    strategy_profile << {id: 4, strategy: accept, payoff: 1, player: employee}
+    gs = Game.new
+    gs.strategy_profiles = strategy_profile
+    gs
+  end
+  
+  # Regular training game -- generic strictly dominated
+  # 
+  #      Employer:            | Task Specific       |    Generic
+  # You:     -----------------|---------------------|------------------
+  #                           |                     |
+  #   Deny Training           |  (-2, 0)            |     (-2, -1)
+  #   ------------------------|---------------------|------------------
+  #   Accept Training         |  (1, 4)             |     (5, -2)
+  #   ------------------------|---------------------|------------------
+  before(:each) do
+    @strategies = Strategy.new [{name: "Accept Training"}, {name: "Generic Training"},{name: "Task Specific Training"},{name: "Deny Training"}]
+    @accept = @strategies.find{|x| x[:name] == "Accept Training"}
+    @generic = @strategies.find{|x| x[:name] == "Generic Training"}
+    @task = @strategies.find{|x| x[:name] == "Task Specific Training"}
+    @deny = @strategies.find{|x| x[:name] == "Deny Training"}
+    @employer = Player.new name: "IBM"
+    @employee = Player.new name: "John Smith"
+
+    @strategy_profile = StrategyProfile.new
+    @strategy_profile << {id: 1, strategy: @generic, payoff: -2, player: @employer}
+    @strategy_profile << {id: 1, strategy: @accept, payoff: 5, player: @employee}
+
+    @strategy_profile << {id: 2, strategy: @generic, payoff: -1, player: @employer}
+    @strategy_profile << {id: 2, strategy: @deny, payoff: -2, player: @employee}
+
+    @strategy_profile << {id: 3, strategy: @task, payoff: 0, player: @employer}
+    @strategy_profile << {id: 3, strategy: @deny, payoff: -2, player: @employee}
+
+    @strategy_profile << {id: 4, strategy: @task, payoff: 4, player: @employer}
+    @strategy_profile << {id: 4, strategy: @accept, payoff: 1, player: @employee}
+    @gs = Game.new
+    @gs.strategy_profiles = @strategy_profile
+  end
+
+  it ".strategies should allow assignment of strategies" do
+    @gs.strategy_profiles.count.should == 8
+  end
+
+  it ".payoff should return the payoff for a strategy and player" do
+    @gs.payoff(@generic, @employer).should == -2 
+  end
+  
+
+  it '.players should return a list of players' do
+    @gs.players.count.should == 2
+  end
+
+  it '.player_names should return a list of player names' do
+    @gs.player_names.count.should == 2
+  end
+
+  it '.opposing_players should return a list of players who receive payouts for the passed in strategy profile' do
+    gen_strat_profile = @gs.strategy_profiles.select{|x| x[:strategy][:name] == "Generic Training"}.first
+    @gs.opposing_players(gen_strat_profile).count.should == 1
+  end
+
+  it '.player_strategy_profiles should return a list of strategy profiles for the players' do
+    @gs.player_strategy_profiles(@employer).count.should == 4
+  end
+
+  it '.complementary_moves? should return a list of strategy profiles for a player other than the passed in profile' do
+    gen_strat_profile = @gs.strategy_profiles.select{|x| x[:strategy][:name] == @generic[:name]}.first
+    @gs.complementary_moves(gen_strat_profile).count.should == 1
+    @gs.complementary_moves(gen_strat_profile).first[:strategy][:name].should == @task[:name]
+  end
+
+  it '.opposing_player_strategy_profile should return the name of the opposing players strategy for the passed in profile' do
+    gen_strat_profile = @gs.strategy_profiles.select{|x| x[:strategy][:name] == @generic[:name]}.first
+    @gs.opposing_player_strategy_profile(gen_strat_profile)[:strategy][:name].should == @accept[:name]
+  end
+
+  it '.better_payoffs? should return a list of strategy profiles that are better than the passed in profile for the passed in player' do
+    gen_strat_profile = @gs.strategy_profiles.select{|x| x[:strategy][:name] == @generic[:name]}.first
+    #@gs.better_moves?(gen_strat_profile).first[:strategy][:name].should == @task[:name]
+    @gs.better_payoffs?(gen_strat_profile).first[:strategy][:name].should == @task[:name]
+  end
+
+  # should return this
+  #      Employer:            | Task Specific       |    Generic
+  # You:     -----------------|---------------------|------------------
+  #                           | get all alternates  | Pass in this
+  #   Deny Training           |  (  , 0)            |     (-2, )
+  #   ------------------------|---------------------|------------------
+  #   Accept Training         |                     |     (5,  )       
+  #   ------------------------|---------------------|------------------
+  it '.worse_payoffs? should return a list of strategy profiles that are worse than the passed in profile for the passed in player'do
+    gen_strat_profile = @gs.strategy_profiles.select{|x| x[:strategy][:name] == @accept[:name]}.first
+    @gs.worse_payoffs?(gen_strat_profile).should_not be_nil
+    @gs.worse_payoffs?(gen_strat_profile).should_not be_empty
+    @gs.worse_payoffs?(gen_strat_profile)[0][:payoff].should == -2
+  end
+
+  #      Employer:            | Task Specific       |    Generic
+  # You:     -----------------|---------------------|------------------
+  #                           |                     |
+  #   Deny Training           |  (-2, -1)           |     (-2, -1)
+  #   ------------------------|---------------------|------------------
+  #   Accept Training         |  (1, 4)             |     (5, -2)
+  #   ------------------------|---------------------|------------------
+  it '.better_or_equal_moves? should return a list of strategy profiles that are better than the passed in profile for the passed in player' do
+    gs = game_with_weakly_dominated_strategies
+    # gets the generic strategy vs the deny training profile
+    gen_strat_profile = gs.strategy_profiles.select{|x| x[:strategy][:name] == @generic[:name]}[1]
+    gs.better_payoffs?(gen_strat_profile).count.should == 0
+    gs.better_or_equal_payoffs?(gen_strat_profile).count.should == 1
+    gs.better_or_equal_payoffs?(gen_strat_profile).first[:strategy][:name].should == @task[:name]
+  end
+
+  it ".strictly_dominated_list should return a list of strictly dominated strategies" do
+    # generic training and deny training are strictly dominated
+    @gs.strictly_dominated_list.count.should == 2
+    @gs.strictly_dominated_list.select{|x| x[:name] == @generic[:name]}.count.should > 0
+    @gs.strictly_dominated_list.select{|x| x[:name] == @deny[:name]}.count.should > 0
+  end
+  
+  #      Employer:            | Task Specific       |    Generic
+  # You:     -----------------|---------------------|------------------
+  #                           |                     |
+  #   Deny Training           |  (-2, -1)           |     (-2, -1)
+  #   ------------------------|---------------------|------------------
+  #   Accept Training         |  (1, 4)             |     (5, -2)
+  #   ------------------------|---------------------|------------------
+  it ".equal_moves should return a list of moves for a matchup that are equal in payoffs" do
+    #  in the above game generic training is weakly dominated
+    gs = game_with_weakly_dominated_strategies
+    gen_strat_profiles = gs.strategy_profiles.select do |x| 
+      x[:strategy][:name] == @generic[:name] &&
+      x[:payoff] == -1
+    end
+    gen_strat_profile = gen_strat_profiles.first
+    gs.equal_moves(gen_strat_profile).count.should == 1
+    gs.equal_moves(gen_strat_profile).first[:payoff].should == -1
+  end
+  
+  #      Employer:            | Task Specific       |    Generic
+  # You:     -----------------|---------------------|------------------
+  #                           |                     |
+  #   Deny Training           |  (-2, -1)           |     (-2, -1)
+  #   ------------------------|---------------------|------------------
+  #   Accept Training         |  (1, 4)             |     (5, -2)
+  #   ------------------------|---------------------|------------------
+  it ".all_other_moves should return a list of moves for a matchup that are equal in payoffs" do
+    #  in the above game generic training is weakly dominated
+    gs = game_with_weakly_dominated_strategies
+    gen_strat_profiles = gs.strategy_profiles.select do |x| 
+      x[:strategy][:name] == @generic[:name] &&
+      x[:payoff] == -1
+    end
+    gen_strat_profile = gen_strat_profiles.first
+    gs.equal_moves(gen_strat_profile).count.should == 1
+    gs.equal_moves(gen_strat_profile).first[:payoff].should == -1
+  end
+
+  #      Employer:            | Task Specific       |    Generic
+  # You:     -----------------|---------------------|------------------
+  #                           |                     |
+  #   Deny Training           |  (-2, -1)           |     (-2, -1)
+  #   ------------------------|---------------------|------------------
+  #   Accept Training         |  (1, 4)             |     (5, -2)
+  #   ------------------------|---------------------|------------------
+  it ".weakly_dominated_list should return a list of weakly dominated strategies" do
+    #  in the above game generic training is weakly dominated
+    gs = game_with_weakly_dominated_strategies
+    # generic should not be strictly but rather weakly dominated
+    gs.strictly_dominated_list.count.should == 1
+    gs.weakly_dominated_list.count.should == 1
+    gs.weakly_dominated_list.select{|x| x[:name] == @generic[:name]}.count.should > 0
+  end
+  it ".weakly_dominated_list should not return ant strictly dominated strategies" do
+    #  in the above game generic training is weakly dominated
+    gs = game_with_weakly_dominated_strategies
+    # generic should not be strictly but rather weakly dominated
+    gs.strictly_dominated_list.count.should == 1
+    gs.weakly_dominated_list.count.should == 1
+    gs.weakly_dominated_list.select{|x| x[:name] == @generic[:name]}.count.should > 0
+    gs.weakly_dominated_list.select{|x| x[:name] == @deny[:name]}.count.should == 0
+  end
+
+  #      Employer:            | Task Specific       |    Generic
+  # You:     -----------------|---------------------|------------------
+  #                           |                     |
+  #   Deny Training           |  (-2, -1)           |     (-2, -1)
+  #   ------------------------|---------------------|------------------
+  #   Accept Training         |  (1, 4)             |     (5, -2)
+  #   ------------------------|---------------------|------------------
+  it ".valid_deviation? should not be nil if the strategy and the deviation belongs to the same player" do
+    gs = game_with_weakly_dominated_strategies
+    gs.valid_deviation?(@deny, @accept).should_not be_nil 
+  end
+
+  it ".valid_deviation? should not be nil if the strategy and the deviation belongs to the same player" do
+    gs = game_with_weakly_dominated_strategies
+    gs.valid_deviation?(@deny, @generic).should == nil 
+  end
+
+  #      Employer:            | Task Specific       |    Generic
+  # You:     -----------------|---------------------|------------------
+  #                           |                     |
+  #   Deny Training           |  (-2, -1)           |     (-2, -1)
+  #   ------------------------|---------------------|------------------
+  #   Accept Training         |  (1, 4)             |     (5, -2)
+  #   ------------------------|---------------------|------------------
+  it ".compare_deviating_strategy should return a list of weakly dominated strategies" do
+    #  in the above game generic training is weakly dominated
+    gs = game_with_weakly_dominated_strategies
+    gs.compare_deviating_strategy(@deny, @accept).should == :strictly_dominated
+  end
+
+  it ".deviating_strategies should return a list of deviations" do
+    gen_strat_payoff = @gs.strategy_profiles.detect{|x| x[:strategy][:name] == @generic[:name]}
+    task_strat_payoff = @gs.strategy_profiles.detect{|x| x[:strategy][:name] == @task[:name]}
+    @gs.deviating_strategies(gen_strat_payoff).include?(gen_strat_payoff[:strategy]).should == false
+    @gs.deviating_strategies(gen_strat_payoff).include?(task_strat_payoff[:strategy]).should == true
+  end
+
+  it ".player_from_strategy should get the player for a particular strategy" do
+    @gs.player_from_strategy(@accept).should eq @employee
+  end
+   
+  it ".best_response should be the action of a player that is best for him given his beliefs about the other's action" do
+    task_strat_payoff = @gs.strategy_profiles.detect{|x| x[:strategy][:name] == @task[:name]}
+    accept_strat_payoff = @gs.strategy_profiles.detect{|x| x[:strategy][:name] == @accept[:name]}
+    @gs.best_response_against(task_strat_payoff)[:strategy][:name].should == accept_strat_payoff[:strategy][:name]
+
+  end  
+  
+  it ".player_enum should get a list of player enumerators" do
+    @gs.player_enum.include?(@employer).should == true 
+  end
+
+  it ".strategies_by_player should get a list of strategies by player" do
+    @gs.strategies_by_player(@employee).include?(@accept).should == true 
+  end
+
+  it ".nash should return a list of strategy profiles that are nash equilibriums" do
+    @gs.nash.include?([@accept[:name],@task[:name]]).should == true 
+  end
+
+   
+end

data/spec/models/player_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Player do
+  it "should check for an required keys when initializing" do
+    players=Player.new 
+    expect {
+      players << {notname: "test1", description: "test2"}
+    }.to raise_error(RuntimeError,/Name required/)
+  end
+
+  it "should allow and insert when name and description are present" do
+    players=Player.new 
+    expect {
+      players << {name: "test1", description: "test2"}
+      players << {name: "test3", description: "test4"}
+    }.to_not raise_error
+  end
+end

data/spec/models/strategy_profile_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe StrategyProfile do
+  # 
+  #      Employer:            | Task Specific       |    Generic
+  # You:     -----------------|---------------------|------------------
+  #                           |                     |
+  #   Deny Training           |  (-2, 0)            |     (-2, -1)
+  #   ------------------------|---------------------|------------------
+  #   Accept Training         |  (1, 4)             |     (5, -2)
+  #   ------------------------|---------------------|------------------
+  before (:each) do
+    @strategies = Strategy.new [{name: "Accept Training"}, {name: "Generic Training"},{name: "Task Specific Training"},{name: "Deny Training"}]
+    @accept = @strategies.find{|x| x[:name] == "Accept Training"}
+    @generic = @strategies.find{|x| x[:name] == "Generic Training"}
+    @task_specific = @strategies.find{|x| x[:name] == "Task Specific Training"}
+    @deny = @strategies.find{|x| x[:name] == "Deny Training"}
+    @employer = Player.new name: "John Smith"
+    @employee = Player.new name: "John Smith"
+  end
+  # hash of stategy, matchup, player, payoff
+  it "should collect matchups" do
+    @strategy_profile = StrategyProfile.new
+    @strategy_profile << {id: 1, strategy: @accept, payoff: -2, player: @employer}
+    @strategy_profile << {id: 1, strategy: @generic, payoff: 5, player: @employee}
+    @strategy_profile.count.should == 2
+    
+  end
+end

data/spec/models/strategy_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Strategy do
+
+  it "should check for an required keys when initializing" do
+    strategies=Strategy.new 
+    expect {
+      strategies << {notname: "test1", description: "test2"}
+    }.to raise_error(RuntimeError,/Name required/)
+  end
+
+  it "should allow and insert when name and description are present" do
+    strategies=Strategy.new 
+    expect {
+      strategies << {name: "test1", description: "test2"}
+      strategies << {name: "test3", description: "test4"}
+    }.to_not raise_error
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,55 @@
+#this file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+#require File.expand_path("../../config/environment", __FILE__)
+require File.expand_path(File.dirname(__FILE__) + '/../lib/minigame/array_of_hashes.rb')
+require File.expand_path(File.dirname(__FILE__) + '/../lib/minigame/strategy.rb')
+require File.expand_path(File.dirname(__FILE__) + '/../lib/minigame/strategy_profile.rb')
+require File.expand_path(File.dirname(__FILE__) + '/../lib/minigame/player.rb')
+require File.expand_path(File.dirname(__FILE__) + '/../lib/minigame/gameable.rb')
+require File.expand_path(File.dirname(__FILE__) + '/../lib/minigame/game.rb')
+require 'rspec/autorun'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+#Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}
+
+Dir["../app/models/*.rb"].each {|f| require_relative f}
+RSpec.configure do |config|
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :rspec
+  
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  #config.fixture_path = "#{::Rails.root}/spec/fixtures"
+    
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  # next line doesn't work with database cleaner
+  #config.use_transactional_fixtures = true
+  
+  # If true, the base class of anonymous controllers will be inferred
+  # automatically. This will be the default behavior in future versions of
+  # rspec-rails.
+  #config.infer_base_class_for_anonymous_controllers = false
+  #config.include FactoryGirl::Syntax::Methods
+    
+  #config.before(:suite) do
+  #  DatabaseCleaner.strategy = :transaction
+  #  DatabaseCleaner.clean_with(:truncation)
+  #end
+  #config.before(:each) do
+  #  DatabaseCleaner.start
+  #end
+
+  #config.after(:each) do
+  #  DatabaseCleaner.clean
+  #end
+
+end
+

data/test/test_minigame.rb

@@ -1,8 +1,8 @@
 require 'minigame'
 require 'minigame/player'
-require 'debugger'
 require 'minitest/autorun'
 require 'minitest/unit'
+#require 'debugger'
 
 class MiniGameTest < Minitest::Test
   class Game
@@ -94,8 +94,8 @@ class MiniGameTest < Minitest::Test
 
   def test_weakly_dominated_list
     game = Game.new
-    game.strategy_profiles = new_profiles
-    assert_equal [{:name=>"Generic Training"}, {:name=>"Deny Training"}], game.weakly_dominated_list
+    game.strategy_profiles = new_weak_profiles
+    assert_equal [{:name=>"Generic Training"}], game.weakly_dominated_list
   end
 
   def test_nash

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minigame
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
-- Wavell Watson
+- W Watson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-13 00:00:00.000000000 Z
+date: 2013-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,15 +52,30 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A game theory library
 email:
-- wavell.watson@gmail.com
+- me@wwatson.me
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
 - .rvmrc
+- .travis.yml
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -70,14 +85,20 @@ files:
 - lib/minigame/array_of_hashes.rb
 - lib/minigame/game.rb
 - lib/minigame/gameable.rb
-- lib/minigame/payoff.rb
 - lib/minigame/player.rb
 - lib/minigame/strategy.rb
 - lib/minigame/strategy_profile.rb
 - lib/minigame/version.rb
 - minigame.gemspec
+- spec/models/array_of_hashes_spec.rb
+- spec/models/gameable_spec.rb
+- spec/models/games_spec.rb
+- spec/models/player_spec.rb
+- spec/models/strategy_profile_spec.rb
+- spec/models/strategy_spec.rb
+- spec/spec_helper.rb
 - test/test_minigame.rb
-homepage: ''
+homepage: https://github.com/wavell/minigame
 licenses:
 - MIT
 metadata: {}
@@ -102,4 +123,11 @@ signing_key:
 specification_version: 4
 summary: A minimalistic game theory library that computes nash equilibrium
 test_files:
+- spec/models/array_of_hashes_spec.rb
+- spec/models/gameable_spec.rb
+- spec/models/games_spec.rb
+- spec/models/player_spec.rb
+- spec/models/strategy_profile_spec.rb
+- spec/models/strategy_spec.rb
+- spec/spec_helper.rb
 - test/test_minigame.rb

data/lib/minigame/payoff.rb

@@ -1,12 +0,0 @@
-require 'data_mapper'
-#class Payoff < ActiveRecord::Base
-#  belongs_to :player
-#  belongs_to :matchup
-#  attr_accessible :payoff
-#end
-class Payoff 
-  include DataMapper::Resource
-  belongs_to :player
-  belongs_to :matchup
-  #attr_accessible :payoff
-end