kindergarten 0.0.5 → 0.1.0

data/.travis.yml

@@ -10,3 +10,12 @@ rvm:
   - jruby-head
   - 1.8.7
   - ree
+
+services: mysql
+before_script:
+  - mysql -e 'create database kindergarten_test;'
+
+branches:
+  only:
+    - master
+    - develop

data/Gemfile

@@ -1,4 +1,19 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in kindergarten.gemspec
-gemspec
+# for travis, use a real gemfile
+gem "cancan", "~> 1.6.8"
+gem "activesupport", "> 3"
+
+group :development do
+  gem "bundler", "~> 1.2"
+  gem "rake"
+  gem "rspec", '~> 2.11'
+  gem "activerecord", "> 3"
+  platforms :jruby do
+    gem 'jdbc-mysql'
+    gem 'activerecord-jdbcmysql-adapter'
+  end
+  platforms :ruby do
+    gem 'mysql2', :git => "git://github.com/brianmario/mysql2.git"
+ end
+end

data/README.md

@@ -29,7 +29,7 @@ child = User.find(2)
 # define a module (perimeter) for the child to play in
 class MyPlayModule < Kindergarten::Perimeter
   # use can-can rules to govern the perimeter
-  govern do |child|
+  govern do
     can :watch, Television
     cannot :watch, CableTV
 

data/TODO.md

@@ -1,6 +1,14 @@
 # Kindergarten TODO
 
-## Travis
+## Code
 
-* Change specs to use ruby-1.8 hashes so Travis can run 1.8.x
-* Switch to mysql for testing jrubies 
+* Further implement ```sandbox.projects.all``` -> ```sandbox.$purpose.$method```
+
+## Documentation
+
+* Write more YARD docs
+* Provide better insight into governess hierarchy
+
+## Wiki
+
+* Write some wiki pages based on the presentation

data/kindergarten.gemspec

@@ -16,10 +16,11 @@ Gem::Specification.new do |gem|
   gem.version       = Kindergarten::VERSION
 
   gem.add_dependency('cancan', ['~> 1.6.8'])
-  gem.add_dependency('activesupport', ['~> 3.2'])
+  gem.add_dependency('activesupport', ['> 3'])
 
   gem.add_development_dependency('rake')
-  gem.add_development_dependency('rspec', ['~> 2.10'])
-  gem.add_development_dependency('activerecord', ['~> 3.2'])
-  gem.add_development_dependency('sqlite3')
+  gem.add_development_dependency('rspec', ['~> 2.11'])
+  gem.add_development_dependency('activerecord', ['> 3'])
+  gem.add_development_dependency('mysql2')
+  gem.add_development_dependency('jdbc-mysql')
 end

data/lib/kindergarten.rb

@@ -3,9 +3,10 @@ require 'active_support/core_ext'
 
 require "kindergarten/version"
 require "kindergarten/sandbox"
-require "kindergarten/exceptions"
-require "kindergarten/governesses"
+require "kindergarten/purpose"
 require "kindergarten/perimeter"
+require "kindergarten/governesses"
+require "kindergarten/exceptions"
 
 module Kindergarten
   class << self

data/lib/kindergarten/exceptions.rb

@@ -12,8 +12,43 @@ module Kindergarten
     end
   end
 
+  class Sandbox
+    class NoPurposeError < NoMethodError
+      def initialize(purpose, sandbox)
+        @purpose = purpose
+        @sandbox = sandbox
+      end
+
+      def to_s
+        "undefined purpose '#{@purpose}' for #{@sandbox}"
+      end
+    end
+  end
+
   class Perimeter
-    # Signals bad sandbox method implementation  
+    class NoExposedMethods < NoMethodError
+      def initialize(perimeter)
+        @perimeter = perimeter
+        super
+      end
+
+      def to_s
+        "The module #{@perimeter.name} does not expose any methods."
+      end
+    end
+
+    class NoPurpose < ArgumentError
+      def initialize(perimeter)
+        @perimeter = perimeter
+        super
+      end
+
+      def to_s
+        "The module #{@perimeter.name} does not have a purpose."
+      end
+    end
+
+    # Signals bad sandbox method implementation
     class Unguarded < SecurityError; end
   end
 end

data/lib/kindergarten/governesses/head_governess.rb

@@ -4,6 +4,7 @@ module Kindergarten
   #
   class HeadGoverness
     include CanCan::Ability
+    attr_reader :child
 
     def initialize(child)
       @child     = child
@@ -130,7 +131,7 @@ module Kindergarten
         untaint = untaint_opts[key]
         next if untaint == :pass
 
-        match = value.match(untaint)
+        match = "#{value}".match(untaint)
         if match.nil?
           scrubbed.delete key
         else

data/lib/kindergarten/perimeter.rb

@@ -5,7 +5,7 @@ module Kindergarten
   #   class ExamplePerimeter < Kindergarten::Perimeter
   #     purpose :books
   #
-  #     govern do |child|
+  #     govern do
   #       can :read, Book do |book|
   #         book.level <= 2
   #       end
@@ -21,13 +21,29 @@ module Kindergarten
   #
   class Perimeter
     class << self
-      attr_reader :sandboxed_methods, :govern_proc
+      attr_reader :exposed_methods, :govern_proc
 
-      # Define a list of sandbox methods
-      def sandbox(*list)
-        @sandboxed_methods ||= []
-        @sandboxed_methods |= list
+      # Defines a list of sandboxed methods
+      #
+      # Can be called multiple times to grow the list.
+      #
+      # @example
+      #   class BondModule < Kindergarten::Perimeter
+      #     # ...
+      #     expose :m, :q
+      #
+      #     # ...
+      #     expose :enemies
+      #   end
+      #
+      #   BondModule.exposed_methods
+      #   => [ :m, :q, :enemies ]
+      #
+      def expose(*list)
+        @exposed_methods ||= []
+        @exposed_methods |= list
       end
+      alias_method :sandbox, :expose
 
       # Instruct the Governess how to govern this perimeter
       def govern(&proc)
@@ -88,31 +104,15 @@ module Kindergarten
       end
     end
 
+    delegate :scrub, :rinse, :guard, :unguarded,
+      :to => :governess
+
     # @return [Array] List of sandbox methods
     def sandbox_methods
-      self.class.sandboxed_methods
-    end
-
-    # @see Governess#scrub
-    def scrub(*args)
-      self.governess.scrub(*args)
-    end
-
-    # @see Governess#rinse
-    def rinse(*args)
-      self.governess.rinse(*args)
-    end
-
-    # @see Governess#guard
-    def guard(action, target)
-      self.governess.guard(action, target)
-    end
-
-    # @see Governess#unguarded
-    def unguarded(&block)
-      self.governess.unguarded(&block)
+      self.class.exposed_methods
     end
 
+    # Perform a block under the watchful eye off the governess
     def governed(method, unguarded=false, &block)
       if unguarded == true
         self.governess.unguarded do

data/lib/kindergarten/purpose.rb

@@ -0,0 +1,41 @@
+module Kindergarten
+  # Keep track of a single purpose
+  class Purpose
+    attr_reader :name, :methods, :sandbox, :subscriptions
+
+    def initialize(name, sandbox)
+      @name          = name
+      @sandbox       = sandbox
+      @methods       = {}
+      @subscriptions = []
+    end
+
+    def add_perimeter(perimeter, instance)
+      if perimeter.exposed_methods.blank?
+        raise Kindergarten::Perimeter::NoExposedMethods.new(perimeter)
+      end
+
+      perimeter.exposed_methods.each do |name|
+        if @methods.has_key?(name)
+          warn "WARNING: overriding already sandboxed method #{@name}.#{name}"
+        end
+
+        @methods[name] = instance
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      super
+
+    rescue NoMethodError => ex
+      unless methods.has_key?(name)
+        raise ex
+      end
+
+      perimeter = methods[name]
+      perimeter.governed(name, sandbox.unguarded?) do
+        perimeter.send(name, *args, &block)
+      end
+    end
+  end
+end

data/lib/kindergarten/sandbox.rb

@@ -1,12 +1,13 @@
 module Kindergarten
   class Sandbox
-    attr_reader :child, :governess, :perimeter
+    attr_reader :child, :governess, :perimeter, :purpose
 
     def initialize(child)
       @child     = child
       @governess = Kindergarten::HeadGoverness.new(child)
 
-      @perimeter   = []
+      @purpose   = {}
+      @perimeter = []
       def @perimeter.include?(other)
         (self.collect(&:class) & [ other.class ]).any?
       end
@@ -25,50 +26,63 @@ module Kindergarten
 
         perimeter = perimeter_class.new(child, governess)
 
+        raise ArgumentError.new(
+          "Module must inherit from Kindergarten::Perimeter"
+        ) unless perimeter.kind_of?(Kindergarten::Perimeter)
+
+        self.extend_purpose(perimeter.class, perimeter)
+
         # the head governess must know all the rules
         unless governess == self.governess || perimeter_class.govern_proc.nil?
           self.governess.instance_eval(&perimeter_class.govern_proc)
         end
 
-        raise ArgumentError.new(
-          "Module must inherit from Kindergarten::Perimeter"
-        ) unless perimeter.kind_of?(Kindergarten::Perimeter)
-
         @perimeter << perimeter unless @perimeter.include?(perimeter)
       end
     end
     alias_method :load_perimeter, :extend_perimeter
     alias_method :load_module, :extend_perimeter
 
+    def extend_purpose(perimeter, instance)
+      name = perimeter.purpose || raise(
+        Kindergarten::Perimeter::NoPurpose.new(perimeter)
+      )
+      name = name.to_sym
+
+      self.purpose[name] ||= Kindergarten::Purpose.new(name, self)
+      self.purpose[name].add_perimeter(perimeter, instance)
+    end
+
     def unguarded(&block)
       @unguarded = true
       yield
       @unguarded = false
     end
 
+    def unguarded?
+      @unguarded == true ? true : false
+    end
+
     def allows?(action, target)
       governess.can?(action, target)
     end
     alias_method :allowed?, :allows?
-    
+
     def disallows?(action, target)
       governess.cannot?(action, target)
     end
     alias_method :disallowed?, :disallows?
 
+    # TODO: Find a purpose and call that - move this block to Purpose
     def method_missing(name, *args, &block)
       super
+
     rescue NoMethodError => ex
-      @perimeter.each do |perimeter|
-        if perimeter.sandbox_methods.include?(name)
-          return perimeter.governed(name, @unguarded) do
-            perimeter.send(name, *args, &block)
-          end
-        end
+      unless purpose.has_key?(name)
+        raise Kindergarten::Sandbox::NoPurposeError.new(name, self)
       end
 
-      # still here? then there is no part of the perimeter that provides method
-      raise ex
+      return purpose[name]
     end
   end
 end

data/lib/kindergarten/version.rb

@@ -1,3 +1,3 @@
 module Kindergarten
-  VERSION = "0.0.5"
+  VERSION = "0.1.0"
 end

data/spec/kindergarten/governess_spec.rb

@@ -27,22 +27,22 @@ describe Kindergarten::HeadGoverness do
 
   describe :washing do
     it "should scrub attributes" do
-      attr     = { a: 1, b: 2, c: 3 }
+      attr     = { :a => 1, :b => 2, :c => 3 }
 
       scrubbed = @governess.scrub(attr, :a, :c)
       scrubbed.should_not be_has_key(:b)
     end
 
     it "should return a ScrubbedHash after scrubbing" do
-      attr     = { a: 1, b: 2, c: 3 }
+      attr     = { :a => 1, :b => 2, :c => 3 }
 
       scrubbed = @governess.scrub(attr, :a, :c)
       scrubbed.should be_kind_of(Kindergarten::ScrubbedHash)
     end
 
     it "should rinse attributes" do
-      attr   = { a: "1", b: "2a", c: "3" }
-      rinsed = @governess.rinse(attr, a: /(\d+)/, b: /(\D+)/)
+      attr   = { :a => 1, :b => "2a", :c => 3 }
+      rinsed = @governess.rinse(attr, :a => /(\d+)/, :b => /(\D+)/)
 
       rinsed.should_not be_has_key(:c)
       rinsed[:a].should eq "1"
@@ -50,16 +50,16 @@ describe Kindergarten::HeadGoverness do
     end
 
     it "should pass attributes" do
-      attr   = { a: "1", b: "2a", c: "3" }
-      rinsed = @governess.rinse(attr, a: :pass, c: :pass)
+      attr   = { :a => "1", :b => "2a", :c => "3" }
+      rinsed = @governess.rinse(attr, :a => :pass, :c => :pass)
 
       rinsed.should_not be_has_key(:b)
       rinsed[:a].should eq "1"
       rinsed[:c].should eq "3"
     end
     it "should return a RinsedHash after rinsing" do
-      attr   = { a: "1", b: "2a", c: "3" }
-      rinsed = @governess.rinse(attr, a: /(\d+)/, b: /(\d+)/)
+      attr   = { :a => "1", :b => "2a", :c => "3" }
+      rinsed = @governess.rinse(attr, :a => /(\d+)/, :b => /(\d+)/)
 
       rinsed.should be_kind_of(Kindergarten::RinsedHash)
     end

data/spec/kindergarten/perimeter_spec.rb

@@ -2,29 +2,32 @@ require 'spec_helper'
 
 describe Kindergarten::Perimeter do
   describe :class do
-    it "should have a :sandbox method" do
-      SpecPerimeter.should respond_to(:sandbox)
-      SpecPerimeter.should respond_to(:sandboxed_methods)
+    it "should have a :expose method" do
+      SpecPerimeter.should respond_to(:expose)
+      SpecPerimeter.should respond_to(:exposed_methods)
     end
-    it "should return sandboxed methods" do
-      SpecPerimeter.sandboxed_methods.should_not be_empty
+    it "should return exposed methods" do
+      SpecPerimeter.exposed_methods.should_not be_empty
     end
-    
+
     it "should have a :govern method" do
       SpecPerimeter.should respond_to(:govern)
       SpecPerimeter.should respond_to(:govern_proc)
     end
-    
+
     it "should return a govern proc" do
       SpecPerimeter.govern_proc.should be_kind_of(Proc)
     end
+
+    it "should return a governess"
+    it "should return a purpose"
   end
 
   describe :instance do
     it "should have an initialize method with 2 arguments" do
       SpecPerimeter.instance.method(:initialize).arity.should == 2
     end
-    
+
     it "should have a :guard method" do
       SpecPerimeter.instance.should respond_to(:guard)
     end
@@ -45,66 +48,66 @@ describe Kindergarten::Perimeter do
       SpecPerimeter.instance.should respond_to(:sandbox_methods)
     end
   end
-  
+
   describe :sandbox do
     before(:each) do
       @sandbox = Kindergarten.sandbox("child")
       @sandbox.extend_perimeter(SpecPerimeter)
     end
-    
+
     it "should have the SpecPerimeter" do
       @sandbox.perimeter.collect(&:class).should include(SpecPerimeter)
     end
-    
+
     it "should fill the governess" do
       @sandbox.governess.should_not be_empty
     end
 
     it "should have the sandboxed method" do
-      @sandbox.sandboxed.should eq "child"
+      @sandbox.testing.sandboxed.should eq "child"
     end
-    
+
     it "should have the guarded method" do
       expect {
-        @sandbox.guarded
+        @sandbox.testing.guarded
       }.to raise_error(Kindergarten::AccessDenied)
     end
-    
+
     it "should not have the unboxed method" do
       expect {
-        @sanbox.unboxed
+        @sanbox.testing.unboxed
       }.to raise_error(NoMethodError)
     end
-    
+
     it "should have the not_guarded method" do
-      @sandbox.not_guarded.should eq "OK"
+      @sandbox.testing.not_guarded.should eq "OK"
     end
-    
+
     it "should have the unsafe method" do
-      expect { 
-        @sandbox.unsafe
+      expect {
+        @sandbox.testing.unsafe
       }.to raise_error(Kindergarten::Perimeter::Unguarded)
     end
   end
-  
+
   describe :unguarded do
     before(:each) do
       @sandbox = Kindergarten.sandbox("child")
       @sandbox.extend_perimeter(SpecPerimeter)
     end
-    
+
     it "should allow the unsafe method" do
-      expect { 
+      expect {
         @sandbox.unguarded do
-          @sandbox.unsafe
+          @sandbox.testing.unsafe
         end
       }.to_not raise_error(Kindergarten::Perimeter::Unguarded)
     end
-    
+
     it "should allow the not_guarded method" do
-      expect { 
+      expect {
         @sandbox.unguarded do
-          @sandbox.not_guarded
+          @sandbox.testing.not_guarded
         end
       }.to_not raise_error(Kindergarten::Perimeter::Unguarded)
     end

data/spec/kindergarten/sandbox_spec.rb

@@ -33,20 +33,54 @@ describe Kindergarten::Sandbox do
       sandbox.perimeter.empty?
     }
   end
-  
+
   describe :HeadGoverness do
     before(:each) do
       @sandbox = Kindergarten::Sandbox.new(:child)
-      @sandbox.extend_perimeter(SpecPerimeter, PuppetPerimeter)      
+      @sandbox.extend_perimeter(SpecPerimeter, PuppetPerimeter)
     end
 
     it "should tell the outside what is allowed" do
       @sandbox.should be_allowed(:view, "string")
     end
-    
+
     it "should know the rules accross perimeters" do
-      puppet = @sandbox.grab_puppet
+      puppet = @sandbox.puppets.grab_puppet
       @sandbox.should be_disallowed(:bbq, puppet)
     end
   end
+
+  describe :Loading do
+    before(:each) do
+      @sandbox = Kindergarten::Sandbox.new(:child)
+    end
+
+    it "should not load a module that has no sandboxed methods" do
+      expect {
+        @sandbox.load_module(MethodlessModule)
+      }.to raise_error(Kindergarten::Perimeter::NoExposedMethods, /MethodlessModule does not expose any methods/)
+    end
+
+    it "should not load a module that has no purpose" do
+      expect {
+        @sandbox.load_module(PurposelessModule)
+      }.to raise_error(Kindergarten::Perimeter::NoPurpose, /PurposelessModule does not have a purpose/)
+    end
+  end
+
+  describe :Purpose do
+    before(:each) do
+      @sandbox = Kindergarten::Sandbox.new(:kid)
+    end
+
+    it "should raise error for wrong purpose" do
+      expect {
+        @sandbox.empty.something
+      }.to raise_error(Kindergarten::Sandbox::NoPurposeError)
+    end
+
+    it "should return a hash of purposes" do
+      @sandbox.purpose.should be_kind_of(Hash)
+    end
+  end
 end

data/spec/orm/active_record_spec.rb

@@ -10,7 +10,7 @@ class Migration < ActiveRecord::Migration
       t.string :street
       t.string :type
     end
-    
+
     create_table :restaurants do |t|
       t.string  :name
       t.text    :description
@@ -30,7 +30,7 @@ end
 
 class Restaurant < ActiveRecord::Base
   include Kindergarten::ORM::Governess
-  
+
   force_rinsed
 end
 
@@ -41,7 +41,7 @@ describe Kindergarten::ORM::ActiveRecord do
       mig.suppress_messages do
         mig.up
       end
-      
+
     rescue => ex
       unless ex.message =~ /already exists/
         $stderr.puts "!!! #{ex.class}: #{ex.message}"
@@ -54,72 +54,72 @@ describe Kindergarten::ORM::ActiveRecord do
       @sandbox = Kindergarten.sandbox(:child)
       @sandbox.extend_perimeter(DrinkingPerimeter)
     end
-  
+
     it "should create a bar" do
       bar = nil
       expect {
-        bar = @sandbox.create_bar( name: "foo", decription: "bar" )
+        bar = @sandbox.get_drunk.create_bar( :name => "Foo", :decription => "A bar" )
       }.to_not raise_error
-      
+
       bar.should be_kind_of(Bar)
     end
-    
+
     it "should not create a bar w/o scrubbing" do
       expect {
-        @sandbox.create_bar_wo( name: "foo", decription: "bar" )
-      }.to raise_error(Kindergarten::ORM::Unscrubbed)    
+        @sandbox.get_drunk.create_bar_wo( :name => "Foo", :decription => "A Bar" )
+      }.to raise_error(Kindergarten::ORM::Unscrubbed)
     end
-    
+
     it "should protect the Joint" do
       expect {
-        @sandbox.create_joint( name: "foo", decription: "bar" )
-      }.to raise_error(Kindergarten::ORM::Unscrubbed)    
+        @sandbox.get_drunk.create_joint( :name => "foo", :decription => "bar" )
+      }.to raise_error(Kindergarten::ORM::Unscrubbed)
     end
-    
+
     it "should build a clean joint" do
       expect {
-        @sandbox.build_joint(name: "clean")
+        @sandbox.get_drunk.build_joint(:name => "clean")
       }.to_not raise_error(Kindergarten::ORM::Unscrubbed)
     end
-    
+
     it "should not build a dirty joint" do
       expect {
-        @sandbox.build_dirty_joint
+        @sandbox.get_drunk.build_dirty_joint
       }.to raise_error(Kindergarten::ORM::Unscrubbed)
     end
-    
+
     it "should update a bar" do
-      bar = @sandbox.create_bar(name: "Whiskey Inn")
+      bar = @sandbox.get_drunk.create_bar(:name => "Whiskey Inn")
       expect {
-        @sandbox.update_bar(bar, name: "Whiskey Out")
+        @sandbox.get_drunk.update_bar(bar, :name => "Whiskey Out")
       }.to_not raise_error(Kindergarten::ORM::Unscrubbed)
     end
-    
+
     it "should not update a dirty bar" do
-      bar = @sandbox.create_bar(name: "Whiskey Inn")
+      bar = @sandbox.get_drunk.create_bar(:name => "Whiskey Inn")
       expect {
-        @sandbox.update_bar_dirty(bar, name: "Whiskey Out")
+        @sandbox.get_drunk.update_bar_dirty(bar, :name => "Whiskey Out")
       }.to raise_error(Kindergarten::ORM::Unscrubbed)
-    end    
+    end
   end
-  
+
   describe :Dining do
     before(:each) do
       @sandbox = Kindergarten.sandbox(:child)
       @sandbox.extend_perimeter(DiningPerimeter)
     end
-    
+
     it "should not create a scrubbed restaurant" do
       expect {
-        @sandbox.create_restaurant_scrubbed(name: "China Wok")
+        @sandbox.eating.create_restaurant_scrubbed(:name => "China Wok")
       }.to raise_error(Kindergarten::ORM::Unscrubbed)
     end
-    
+
     it "should create a rinsed restaurant" do
       expect {
-        @sandbox.create_restaurant(name: "Lobster Inn")
+        @sandbox.eating.create_restaurant(:name => "Lobster Inn")
       }.to_not raise_error(Kindergarten::ORM::Unscrubbed)
     end
   end
-    
-end
+
+end

data/spec/orm_helper.rb

@@ -1,4 +1,6 @@
-require 'sqlite3'
+adapter = RUBY_PLATFORM == 'java' ? 'jdbc/mysql' : 'mysql2'
+require adapter
+
 require 'active_record'
 require "kindergarten/orm/governess"
 
@@ -9,7 +11,8 @@ logger.formatter = proc { |severity, datetime, progname, msg|
 
 ActiveRecord::Base.logger = logger
 ActiveRecord::Base.establish_connection(
-  :adapter   => 'sqlite3',
-  :database  => File.expand_path( "../support/db/test.db", __FILE__),
+  :adapter   => adapter.gsub('/', ''),
+  :database  => 'kindergarten_test',
+  :username  => 'root',
+  :encoding  => 'utf8'
 )
-

data/spec/support/dining_perimeter.rb

@@ -1,14 +1,16 @@
 class DiningPerimeter < Kindergarten::Perimeter
+  purpose :eating
+
   # should raise Unscrubbed
   def create_restaurant_scrubbed(args)
     Restaurant.create(scrub(args, :name, :description))
   end
-  
+
   # should work
   def create_restaurant(args)
     safe = rinse(args, :name => /([\w\s\-]+)/, :description => :pass)
     Restaurant.create(safe)
   end
-  
+
   sandbox :create_restaurant_scrubbed, :create_restaurant
-end
+end

data/spec/support/drinking_perimeter.rb

@@ -1,39 +1,41 @@
 class DrinkingPerimeter < Kindergarten::Perimeter
+  purpose :get_drunk
+
   # supposed to work
   def create_bar(args)
     Bar.create(scrub(args, :name, :description))
   end
-  
+
   # should raise Unscrubbed
   def create_bar_wo(args)
     Bar.create(args)
   end
-  
+
   # should raise Unscrubbed
   def create_joint(args)
     Joint.create(args)
   end
-  
+
   # should not raise Unscrubbed
   def build_joint(args)
     Joint.new(scrub(args, :name))
   end
-  
+
   # should raise Unscrubbed
   def build_dirty_joint
-    Joint.new(name: "dirty")
+    Joint.new(:name => "dirty")
   end
-  
+
   # should not raise Unscrubbed
   def update_bar(bar, args)
     bar.update_attributes(scrub(args, :name, :city, :street))
   end
-  
+
   # should raise
   def update_bar_dirty(bar, args)
     bar.update_attributes(args)
   end
-  
+
   sandbox :create_bar, :create_bar_wo, :create_joint, :build_joint,
     :build_dirty_joint, :update_bar, :update_bar_dirty
-end
+end

data/spec/support/methodless_module.rb

@@ -0,0 +1,3 @@
+class MethodlessModule < Kindergarten::Perimeter
+  purpose :none
+end

data/spec/support/puppet_perimeter.rb

@@ -1,8 +1,10 @@
 class PuppetPerimeter < Kindergarten::Perimeter
+  purpose :puppets
+
   class Puppet
   end
 
-  govern do |child|
+  govern do
     can [:play_with,:dress,:nappy_change], Puppet
     cannot [:tear, :bbq], Puppet
   end
@@ -16,4 +18,4 @@ class PuppetPerimeter < Kindergarten::Perimeter
   end
 
   sandbox :grab_puppet, :play_puppet
-end
+end

data/spec/support/purposeless_module.rb

@@ -0,0 +1,7 @@
+class PurposelessModule < Kindergarten::Perimeter
+  sandbox :someting
+
+  def something
+    "x"
+  end
+end

data/spec/support/spec_perimeter.rb

@@ -1,7 +1,9 @@
 class SpecPerimeter < Kindergarten::Perimeter
+  purpose :testing
+
   governess Kindergarten::StrictGoverness
 
-  govern do |child|
+  govern do
     can :view, String
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kindergarten
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-24 00:00:00.000000000 Z
+date: 2012-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cancan
-  requirement: &29385360 !ruby/object:Gem::Requirement
+  requirement: &24991920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,21 +21,21 @@ dependencies:
         version: 1.6.8
   type: :runtime
   prerelease: false
-  version_requirements: *29385360
+  version_requirements: *24991920
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &29381580 !ruby/object:Gem::Requirement
+  requirement: &24991400 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>'
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3'
   type: :runtime
   prerelease: false
-  version_requirements: *29381580
+  version_requirements: *24991400
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &29380560 !ruby/object:Gem::Requirement
+  requirement: &24991020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,32 +43,43 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *29380560
+  version_requirements: *24991020
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &29379620 !ruby/object:Gem::Requirement
+  requirement: &24990460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: '2.11'
   type: :development
   prerelease: false
-  version_requirements: *29379620
+  version_requirements: *24990460
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &29378540 !ruby/object:Gem::Requirement
+  requirement: &24989940 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: *24989940
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: &24989560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *29378540
+  version_requirements: *24989560
 - !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: &29377500 !ruby/object:Gem::Requirement
+  name: jdbc-mysql
+  requirement: &24989100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +87,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *29377500
+  version_requirements: *24989100
 description: A kindergarten with a perimeter, a governess and a sandbox
 email:
 - hartog@organisedminds.com
@@ -102,6 +113,7 @@ files:
 - lib/kindergarten/orm/active_record.rb
 - lib/kindergarten/orm/governess.rb
 - lib/kindergarten/perimeter.rb
+- lib/kindergarten/purpose.rb
 - lib/kindergarten/sandbox.rb
 - lib/kindergarten/version.rb
 - spec/kindergarten/governess_spec.rb
@@ -116,7 +128,9 @@ files:
 - spec/support/dining_perimeter.rb
 - spec/support/drinking_perimeter.rb
 - spec/support/log/.gitkeep
+- spec/support/methodless_module.rb
 - spec/support/puppet_perimeter.rb
+- spec/support/purposeless_module.rb
 - spec/support/spec_perimeter.rb
 homepage: ''
 licenses: []