kindergarten 0.0.5

data/lib/kindergarten/orm/active_record.rb

@@ -0,0 +1,42 @@
+module Kindergarten::ORM
+  module ActiveRecord
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    def update_attributes(hash)
+      self.class.check(:update_attributes, hash)
+    end
+    
+    module ClassMethods
+      def create(*args)
+        check(:create, *args)
+        super
+      end
+      
+      def new(*args)
+        check(:new, *args)
+        super
+      end
+      
+      def check(method, *args)
+        required = self.force_rinsed? ?
+          Kindergarten::RinsedHash : 
+          Kindergarten::ScrubbedHash
+
+        if args[0].is_a?(Array)
+          args.each do |input|
+            raise Unscrubbed unless input.is_a?(required) 
+          end
+
+        elsif args[0].is_a?(Hash)
+          raise Unscrubbed unless args[0].is_a?(required)
+          
+        elsif args.any?
+          warn "WARNING: #{self.name}.#{method} called with unkown signature"
+          
+        end
+      end
+    end
+  end
+end

data/lib/kindergarten/orm/governess.rb

@@ -0,0 +1,41 @@
+module Kindergarten
+  module ORM
+
+    # An exception to throw when unscrubbed input is provided
+    class Unscrubbed < ArgumentError
+      def initialize(msg=nil)
+        @msg = msg || "Unscrubbed input provided"
+      end
+      
+      def to_s
+        @msg
+      end
+    end
+    
+    # Provide ORM tidyness
+    module Governess
+      def self.included(base)
+        if base.ancestors.include?(::ActiveRecord::Base)
+          base.send(:include, Kindergarten::ORM::ActiveRecord)
+        else
+          raise "Your ORM #{base.superclass} for #{base} is not supported (yet)"
+        end
+        
+        base.extend Modes
+      end
+      
+      module Modes
+        def force_rinsed
+          @force_rinsed = true
+        end
+        
+        def force_rinsed?
+          @force_rinsed == true ? true : false
+        end
+      end
+    end
+
+  end
+end
+
+require 'kindergarten/orm/active_record'

data/lib/kindergarten/perimeter.rb

@@ -0,0 +1,129 @@
+module Kindergarten
+  # A Perimeter is used to define the places where the child can play.
+  #
+  # @example
+  #   class ExamplePerimeter < Kindergarten::Perimeter
+  #     purpose :books
+  #
+  #     govern do |child|
+  #       can :read, Book do |book|
+  #         book.level <= 2
+  #       end
+  #     end
+  #
+  #     def read(book)
+  #       guard(:read, book)
+  #       book.read
+  #     end
+  #
+  #     sandbox :read
+  #   end
+  #
+  class Perimeter
+    class << self
+      attr_reader :sandboxed_methods, :govern_proc
+
+      # Define a list of sandbox methods
+      def sandbox(*list)
+        @sandboxed_methods ||= []
+        @sandboxed_methods |= list
+      end
+
+      # Instruct the Governess how to govern this perimeter
+      def govern(&proc)
+        @govern_proc = proc
+      end
+
+      # Get/set the purpose of the perimeter
+      def purpose(*purpose)
+        purpose.any? ? @purpose = purpose[0] : @purpose
+      end
+
+      # Get/set the governess of the perimeter
+      def governess(*klass)
+        klass.any? ? @governess = klass[0] : @governess
+      end
+
+      # Subscribe to an event from a given purpose
+      # @param [Symbol] purpose Listen to other perimeters that have this
+      #   purpose
+      # @param [Symbol] event Listen for events with this name
+      # @param [Proc,Symbol] block Invoke this on the event
+      # @example Symbol form
+      #   subscribe :users, :create, :user_created
+      #
+      #   def user_created(event)
+      #     # ...
+      #   end
+      #
+      # @example Block form
+      #   subscribe :users, :update do |event|
+      #     # ...
+      #   end
+      #
+      def subscribe(purpose, event, block)
+        @callbacks ||= {}
+        @callbacks[purpose] ||= {}
+        @callbacks[purpose][event] ||= []
+        @callbacks[purpose][event] << block
+      end
+    end
+
+    attr_reader :child, :governess
+
+    # Obtain an un-sandboxed instance for testing purposes
+    #
+    # @return [Perimeter] with the given child and/or governess
+    #
+    def self.instance(child=nil, governess=nil)
+      self.new(child, governess)
+    end
+
+    def initialize(child, governess)
+      @child     = child
+      @governess = governess
+
+      unless @governess.nil? || self.class.govern_proc.nil?
+        @governess.instance_eval(&self.class.govern_proc)
+      end
+    end
+
+    # @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)
+    end
+
+    def governed(method, unguarded=false, &block)
+      if unguarded == true
+        self.governess.unguarded do
+          self.governess.governed(method, &block)
+        end
+
+      else
+        self.governess.governed(method, &block)
+
+      end
+    end
+
+  end
+end

data/lib/kindergarten/sandbox.rb

@@ -0,0 +1,76 @@
+module Kindergarten
+  class Sandbox
+    attr_reader :child, :governess, :perimeter
+
+    def initialize(child)
+      @child     = child
+      @governess = Kindergarten::HeadGoverness.new(child)
+
+      @perimeter   = []
+      def @perimeter.include?(other)
+        (self.collect(&:class) & [ other.class ]).any?
+      end
+
+      @unguarded = false
+    end
+
+    def extend_perimeter(*perimeter_classes)
+      perimeter_classes.each do |perimeter_class|
+        # if the perimeter specifies a governess, use that - otherwise appoint
+        # the head governess
+        child     = self.child
+        governess = perimeter_class.governess ?
+          perimeter_class.governess.new(child) :
+          self.governess
+
+        perimeter = perimeter_class.new(child, governess)
+
+        # 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 unguarded(&block)
+      @unguarded = true
+      yield
+      @unguarded = 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?
+
+    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
+      end
+
+      # still here? then there is no part of the perimeter that provides method
+      raise ex
+    end
+  end
+end
+
+

data/lib/kindergarten/version.rb

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

data/spec/kindergarten/governess_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Kindergarten::HeadGoverness do
+  before(:each) do
+    @governess = Kindergarten::HeadGoverness.new("child")
+  end
+
+  it "should include CanCan ability" do
+    @governess.should be_kind_of(CanCan::Ability)
+  end
+
+  describe :governing do
+    it "should guard the child" do
+      expect {
+        @governess.guard(:free, "Willy")
+      }.to raise_error(Kindergarten::AccessDenied)
+    end
+
+    it "should keep a closed eye" do
+      expect {
+        @governess.unguarded do
+          @governess.guard(:free, "Willy")
+        end
+      }.to_not raise_error(Kindergarten::AccessDenied)
+    end
+  end
+
+  describe :washing do
+    it "should scrub attributes" do
+      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 }
+
+      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+)/)
+
+      rinsed.should_not be_has_key(:c)
+      rinsed[:a].should eq "1"
+      rinsed[:b].should eq "a"
+    end
+
+    it "should pass attributes" do
+      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+)/)
+
+      rinsed.should be_kind_of(Kindergarten::RinsedHash)
+    end
+  end
+end

data/spec/kindergarten/perimeter_spec.rb

@@ -0,0 +1,112 @@
+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)
+    end
+    it "should return sandboxed methods" do
+      SpecPerimeter.sandboxed_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
+  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
+
+    it "should have an :unguarded method" do
+      SpecPerimeter.instance.should respond_to(:unguarded)
+    end
+
+    it "should have a :scrub method" do
+      SpecPerimeter.instance.should respond_to(:scrub)
+    end
+
+    it "should have a :rinse method" do
+      SpecPerimeter.instance.should respond_to(:rinse)
+    end
+
+    it "should have a :sandbox_methods method" 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"
+    end
+    
+    it "should have the guarded method" do
+      expect {
+        @sandbox.guarded
+      }.to raise_error(Kindergarten::AccessDenied)
+    end
+    
+    it "should not have the unboxed method" do
+      expect {
+        @sanbox.unboxed
+      }.to raise_error(NoMethodError)
+    end
+    
+    it "should have the not_guarded method" do
+      @sandbox.not_guarded.should eq "OK"
+    end
+    
+    it "should have the unsafe method" do
+      expect { 
+        @sandbox.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 { 
+        @sandbox.unguarded do
+          @sandbox.unsafe
+        end
+      }.to_not raise_error(Kindergarten::Perimeter::Unguarded)
+    end
+    
+    it "should allow the not_guarded method" do
+      expect { 
+        @sandbox.unguarded do
+          @sandbox.not_guarded
+        end
+      }.to_not raise_error(Kindergarten::Perimeter::Unguarded)
+    end
+  end
+end