consul 0.1.2 → 0.2.0

data/lib/consul.rb

@@ -1,3 +1,4 @@
 require 'consul/power'
 require 'consul/errors'
 require 'consul/controller'
+require 'consul/active_record'

data/lib/consul/active_record.rb

@@ -0,0 +1,14 @@
+module Consul
+  module ActiveRecord
+
+    private
+
+    def authorize_values_for(property, options = {})
+      method_defined?(:power) or attr_accessor :power
+      assignable_values_for property, options.merge(:through => lambda { ::Power.current })
+    end
+
+  end
+end
+
+ActiveRecord::Base.send(:extend, Consul::ActiveRecord)

data/lib/consul/controller.rb

@@ -8,6 +8,14 @@ module Consul
 
     module ClassMethods
 
+      def current_power_initializer
+        @current_power_initializer || (superclass.respond_to?(:current_power_initializer) && superclass.current_power_initializer)
+      end
+
+      def current_power_initializer=(initializer)
+        @current_power_initializer = initializer
+      end
+
       private
 
       def require_power_check(options = {})
@@ -18,6 +26,12 @@ module Consul
         skip_before_filter :unchecked_power, options
       end
 
+      def current_power(&initializer)
+        self.current_power_initializer = initializer
+        around_filter :with_current_power
+        helper_method :current_power
+      end
+
       def power(*args)
 
         args_copy = args.dup
@@ -72,6 +86,21 @@ module Consul
         raise Consul::UncheckedPower, "This controller does not check against a power"
       end
 
+      def current_power
+        @current_power_class && @current_power_class.current
+      end
+
+      def with_current_power(&action)
+        power = instance_eval(&self.class.current_power_initializer) or raise Consul::Error, 'current_power initializer returned nil'
+        @current_power_class = power.class
+        @current_power_class.current = power
+        action.call
+      ensure
+        if @current_power_class
+          @current_power_class.current = nil
+        end
+      end
+
     end
 
   end

data/lib/consul/errors.rb

@@ -1,5 +1,6 @@
 module Consul
-  class Powerless < StandardError; end
-  class UncheckedPower < StandardError; end
-  class UnmappedAction < StandardError; end
+  class Error < StandardError; end
+  class Powerless < Error; end
+  class UncheckedPower < Error; end
+  class UnmappedAction < Error; end
 end

data/lib/consul/power.rb

@@ -50,6 +50,8 @@ module Consul
         "#{name.to_s.singularize}_ids"
       end
 
+      attr_accessor :current
+
     end
 
   end

data/lib/consul/version.rb

@@ -0,0 +1,3 @@
+module Consul
+  VERSION = '0.2.0'
+end

data/spec/app_root/app/controllers/application_controller.rb

@@ -3,10 +3,8 @@ class ApplicationController < ActionController::Base
 
   require_power_check
 
-  private
-
-  def current_power
-    Power.new User.new
+  current_power do
+    Power.new(User.new)
   end
   
 end

data/spec/app_root/app/controllers/dashboards_controller.rb

@@ -1,8 +1,19 @@
 class DashboardsController < ApplicationController
   
-  power :dashboard
+  power :always_true
 
   def show
+    observe(current_power)
+  end
+
+  def error
+    raise 'error during action'
+  end
+
+  private
+
+  def observe(object)
+    # test spy
   end
 
 end

data/spec/app_root/app/controllers/songs_controller.rb

@@ -1,13 +1,12 @@
 class SongsController < ApplicationController
 
-  # power check is missing
-
-  skip_power_check :only => :index
+  # power check is missing, but we're skipping it for a single action'
+  skip_power_check :only => :show
 
   def show
   end
 
-  def index
+  def update
   end
 
 end

data/spec/app_root/app/controllers/users_controller.rb

@@ -1,11 +1,11 @@
 class UsersController < ApplicationController
 
-  power :admin, :map => { :index => :dashboard }
+  power :always_false, :map => { :show => :always_true }
 
-  def index
+  def show
   end
 
-  def show
+  def update
   end
 
 end

data/spec/app_root/app/models/power.rb

@@ -1,7 +1,7 @@
 class Power
   include Consul::Power
 
-  def initialize(user)
+  def initialize(user = nil)
     @user = user
   end
 
@@ -17,16 +17,20 @@ class Power
     Note.scoped(:joins => :client)
   end
 
-  power :admin do
+  power :always_true do
+    true
+  end
+
+  power :always_false do
     false
   end
 
-  power :moderator do
+  power :always_nil do
     nil
   end
-  
-  power :dashboard do
-    true
+
+  def assignable_user_roles
+    %w[guest admin]
   end
 
 end

data/spec/app_root/config/routes.rb

@@ -1,6 +1,6 @@
 ActionController::Routing::Routes.draw do |map|
 
-  map.resource :dashboard
+  map.resource :dashboard, :member => { :error => :post }
 
   map.resources :songs
 

data/spec/app_root/db/migrate/001_create_users.rb

@@ -1,7 +1,9 @@
 class CreateUsers < ActiveRecord::Migration
 
   def self.up
-    create_table :users
+    create_table :users do |t|
+      t.string :role
+    end
   end
 
   def self.down

data/spec/consul/active_record_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Consul::ActiveRecord do
+
+  describe '.authorize_values_for' do
+
+    it 'should be a shortcut for .assignable_values_for :attribute, :through => lambda { ::Power.current }' do
+      klass = Note.disposable_copy
+      klass.should_receive(:assignable_values_for).with(:attribute, :option => 'option', :through => kind_of(Proc))
+      klass.class_eval do
+        authorize_values_for :attribute, :option => 'option'
+      end
+    end
+
+    it 'should generate a getter and setter for a @power field' do
+      klass = Note.disposable_copy do
+        authorize_values_for :attribute
+      end
+      song = klass.new
+      song.should respond_to(:power)
+      song.should respond_to(:power=)
+    end
+
+    it 'should obtain assignable values from Power.current' do
+      Power.current = Power.new
+      klass = User.disposable_copy do
+        authorize_values_for :role
+      end
+      user = klass.new
+      user.assignable_roles.should =~ %w[guest admin]
+      user.should allow_value('guest').for(:role)
+      user.should_not allow_value('invalid-value').for(:role)
+    end
+
+  end
+
+end

data/spec/consul/power_spec.rb

@@ -72,15 +72,15 @@ describe Consul::Power do
     end
 
     it 'should return true when the queried power is not a scope, but returns true' do
-      @user.power.dashboard?.should be_true
+      @user.power.always_true?.should be_true
     end
 
     it 'should return false when the queried power is not a scope, but returns false' do
-      @user.power.admin?.should be_false
+      @user.power.always_false?.should be_false
     end
 
     it 'should return false when the queried power is not a scope, but returns nil' do
-      @user.power.moderator?.should be_false
+      @user.power.always_nil?.should be_false
     end
 
   end
@@ -100,15 +100,26 @@ describe Consul::Power do
     end
 
     it 'should not raise Consul::Powerless when the queried power is not a scope, but returns true' do
-      expect { @user.power.dashboard! }.to_not raise_error
+      expect { @user.power.always_true! }.to_not raise_error
     end
 
     it 'should raise Consul::Powerless when the queried power is not a scope, but returns false' do
-      expect { @user.power.admin! }.to raise_error
+      expect { @user.power.always_false! }.to raise_error(Consul::Powerless)
     end
 
     it 'should raise Consul::Powerless when the queried power is not a scope, but returns nil' do
-      expect { @user.power.moderator! }.to raise_error
+      expect { @user.power.always_nil! }.to raise_error(Consul::Powerless)
+    end
+
+  end
+
+  describe '.current' do
+
+    it 'should provide a class method to set and get the current Power' do
+      Power.current = 'current power'
+      Power.current.should == 'current power'
+      Power.current = nil
+      Power.current.should be_nil
     end
 
   end

data/spec/controllers/dashboards_controller_spec.rb

@@ -6,4 +6,21 @@ describe DashboardsController do
     expect { get :show }.to_not raise_error
   end
 
+  it 'should define a method #current_power that returns the Power' do
+    controller.should_receive(:observe).with(kind_of(Power))
+    get :show
+  end
+
+  it "should set the current power before the request, and nilify it after the request" do
+    controller.send(:current_power).should be_nil
+    Power.should_receive_and_execute(:current=).ordered.with(kind_of(Power))
+    Power.should_receive_and_execute(:current=).ordered.with(nil)
+    get :show
+  end
+
+  it 'should nilify the current power even if the action raises an error' do
+    expect { post :error }.to raise_error(/error during action/)
+    Power.current.should be_nil
+  end
+
 end

data/spec/controllers/songs_controller_spec.rb

@@ -2,12 +2,12 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 describe SongsController do
 
-  it "should raise an error if an action is not checked against a power" do
-    expect { get :show, :id => '123' }.to raise_error(Consul::UncheckedPower)
+  it 'should allow to skip a required power check' do
+    expect { get :show, :id => '1' }.to_not raise_error
   end
 
-  it 'should allow to skip a required power check' do
-    expect { get :index }.to_not raise_error
+  it "should raise an error if an action is not checked against a power" do
+    expect { put :update, :id => '1' }.to raise_error(Consul::UncheckedPower)
   end
 
 end

data/spec/controllers/users_controller_spec.rb

@@ -3,11 +3,11 @@ require File.dirname(__FILE__) + '/../spec_helper'
 describe UsersController do
 
   it "should raise an error if the checked power is not given" do
-    expect { get :show, :id => '1' }.to raise_error(Consul::Powerless)
+    expect { get :update, :id => '1' }.to raise_error(Consul::Powerless)
   end
 
-  it 'should allow to map actions to another power' do
-    expect { get :index }.to_not raise_error
+  it 'should allow to map actions to another power using the :map option' do
+    expect { get :show, :id => '1' }.to_not raise_error
   end
 
 end

data/spec/spec_helper.rb

@@ -5,12 +5,21 @@ ENV['RAILS_ENV'] ||= 'in_memory'
 
 # Load the Rails environment and testing framework
 require "#{File.dirname(__FILE__)}/app_root/config/environment"
-require "#{File.dirname(__FILE__)}/../lib/consul"
 require 'spec/rails'
 
+# Load dependencies
+require 'assignable_values'
+require 'shoulda-matchers'
+
+# Load the gem itself
+require "#{File.dirname(__FILE__)}/../lib/consul"
+
 # Undo changes to RAILS_ENV
 silence_warnings {RAILS_ENV = ENV['RAILS_ENV']}
 
+# Requires supporting files with custom matchers and macros, etc in ./support/ and its subdirectories.
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
+
 # Run the migrations
 ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate")
 

data/spec/support/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/support/spec_candy.rb

@@ -0,0 +1,179 @@
+# From https://makandracards.com/makandra/627-the-definitive-spec_candy-rb-rspec-helper
+Object.class_eval do
+
+  def should_receive_chain(*parts)
+    setup_expectation_chain(parts)
+  end
+
+  def self.new_with_stubs(attrs)
+    new.tap do |obj|
+      obj.stub_existing attrs
+    end
+  end
+
+  def stub_existing(attrs)
+    attrs.each do |method, value|
+      if respond_to?(method, true)
+        stub(method => value)
+      else
+        raise "Attempted to stub non-existing method ##{method} on a #{self.class.name}"
+      end
+    end
+  end
+
+  def should_receive_and_return(methods_and_values)
+    methods_and_values.each do |method, value|
+      should_receive(method).and_return(value)
+    end
+  end
+
+  def should_receive_all_with(methods_and_values)
+    methods_and_values.each do |method, value|
+      should_receive(method).with(value)
+    end
+  end
+
+  def should_not_receive_and_execute(method)
+    should_receive_and_execute(method, true)
+  end
+
+  def should_receive_and_execute(method, negate = false)
+    method_base = method.to_s.gsub(/([\?\!\=\[\]]+)$/, '')
+    method_suffix = $1
+
+    method_called = "_#{method_base}_called#{method_suffix}"
+    method_with_spy = "#{method_base}_with_spy#{method_suffix}"
+    method_without_spy = "#{method_base}_without_spy#{method_suffix}"
+
+    prototype = respond_to?(:singleton_class) ? singleton_class : metaclass
+    prototype.class_eval do
+
+      unless method_defined?(method_with_spy)
+
+        define_method method_called do
+        end
+
+        define_method method_with_spy do |*args, &block|
+          send(method_called, *args)
+          send(method_without_spy, *args, &block)
+        end
+        alias_method_chain method, :spy
+      end
+
+    end
+
+    expectation = negate ? :should_not_receive : :should_receive
+    send(expectation, method_called)
+  end
+
+  private
+
+  def setup_expectation_chain(parts)
+    obj = self
+    for part in parts
+      if part == parts.last
+        obj = add_expectation_chain_link(obj, part)
+      else
+        next_obj = Spec::Mocks::Mock.new('chain link')
+        add_expectation_chain_link(obj, part).at_least(:once).and_return(next_obj)
+        obj = next_obj
+      end
+    end
+    obj
+  end
+
+  def add_expectation_chain_link(obj, part)
+    if part.is_a?(Array)
+      obj.should_receive(part.first).with(*part[1..-1])
+    else
+      obj.should_receive(part)
+    end
+  end
+
+end
+
+Spec::Example::ExampleGroupMethods.class_eval do
+
+  # Improves it_should_behave_like in some ways:
+  # - It scopes the reused examples so #let und #subject does not bleed into the reusing example groups
+  # - It allows to parametrize the reused example group by appending a hash argument.
+  #   Every key/value pair in the hash will become a #let variable for the reused example group
+  # - You can call it with a block. It will be available to the reused example group as let(:block)
+  def it_should_act_like(shared_example_group, environment = {}, &block)
+    description = "as #{shared_example_group}"
+    description << " (#{environment.inspect})" if environment.present?
+    describe description do
+      environment.each do |name, value|
+        let(name) { value }
+      end
+      let(:block) { block } if block
+      it_should_behave_like(shared_example_group)
+    end
+  end
+
+end
+
+Spec::Rails::Example::ModelExampleGroup.class_eval do
+
+  def self.it_should_run_callbacks_in_order(*callbacks)
+    callbacks.push(:ordered => true)
+    it_should_run_callbacks(*callbacks)
+  end
+
+  def self.it_should_run_callbacks(*callbacks)
+    options = callbacks.last.is_a?(Hash) ? callbacks.pop : {}
+    reason = callbacks.pop if callbacks.last.is_a?(String)
+    hook = description_parts.last.sub(/^#/, '')
+    should = ['should run callbacks', callbacks.inspect, ('in order' if options[:ordered]), reason].compact.join ' '
+    send(:it, should) do
+      callbacks.each do |callback|
+        expectation = subject.should_receive(callback).once
+        expectation.ordered if options[:ordered]
+      end
+      run_state_machine_callbacks_from_prose(hook) || subject.run_callbacks(hook)
+    end
+  end
+
+  private
+
+  def run_state_machine_callbacks_from_prose(prose)
+    if parts = prose.match(/^(\w+) from ([\:\w]+) to ([\:\w]+)$/)
+      name = parts[1].to_sym
+      from = parts[2].sub(/^:/, '').to_sym
+      to = parts[3].sub(/^:/, '').to_sym
+      transition = StateMachine::Transition.new(subject, subject.class.state_machine, name, from, to)
+      transition.run_callbacks
+    end
+  end
+
+end
+
+ActiveRecord::Base.class_eval do
+
+  # Prevents the databse from being touched, but still runs all validations.
+  def keep_invalid!
+    errors.stub :empty? => false
+  end
+
+end
+
+Class.class_eval do
+
+  define_method :stub_any_instance do |stubs|
+    unstubbed_new = method(:new)
+    stub(:new).and_return do |*args|
+      unstubbed_new.call(*args).tap do |obj|
+        obj.stub stubs
+      end
+    end
+    stubs
+  end
+
+  define_method :disposable_copy do |&body|
+    this = self
+    copy = Class.new(self, &body)
+    copy.singleton_class.send(:define_method, :name) { this.name }
+    copy
+  end
+
+end