consul 0.3.0 → 0.4.0

data/Gemfile

@@ -1,3 +0,0 @@
-source :rubygems
-
-gemspec

data/spec/consul/power_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-
-describe Consul::Power do
-
-  before :each do
-    @user = User.create!
-    @deleted_client = Client.create!(:deleted => true)
-    @client1 = Client.create!
-    @client1_note1 = @client1.notes.create!
-    @client1_note2 = @client1.notes.create!
-    @client2 = Client.create!
-    @client2_note1 = @client2.notes.create!
-    @client2_note2 = @client2.notes.create!
-  end
-
-  describe 'example scenario' do
-
-    it 'should work as expected' do
-      Client.active.should == [@client1, @client2]
-      @client1.notes.should == [@client1_note1, @client1_note2] 
-    end
-
-  end
-
-  describe 'scope methods' do
-
-    it 'should return the registered scope' do
-      @user.power.clients.all.should == [@client1, @client2]
-    end
-
-    it 'should allow to register scopes with arguments' do
-      @user.power.client_notes(@client1).should == [@client1_note1, @client1_note2]
-    end
-
-  end
-
-  describe 'scope_ids methods' do
-
-    it 'should return record ids that match the registered scope' do
-      @user.power.client_ids.should == [@client1.id, @client2.id]
-    end
-
-    it 'should cache scope ids' do
-      @user.power.should_receive(:clients).once.and_return(double('scope', :construct_finder_sql => 'SELECT 1').as_null_object)
-      2.times { @user.power.client_ids }
-    end
-
-    it 'should return ids when the scope joins another table (bugfix)' do
-      expect { @user.power.note_ids }.to_not raise_error
-    end
-
-  end
-
-  describe 'include?' do
-
-    it 'should return true if a given record belongs to a scope' do
-      @user.power.client?(@client1).should be_true
-    end
-
-    it 'should return false if a given record does not belong to a scope' do
-      @user.power.client?(@deleted_client).should be_false
-    end
-
-    it 'should only trigger a single query for multiple checks on the same scope' do
-      ActiveRecord::Base.connection.should_receive(:select_values).once.and_return([]) #.and_return(double('connection').as_null_object)
-      @user.power.client?(@client1)
-      @user.power.client?(@deleted_client)
-    end
-
-    it 'should return true when the queried power returns a scope (which might or might not match records)' do
-      @user.power.clients?.should be_true
-    end
-
-    it 'should return true when the queried power is not a scope, but returns true' do
-      @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.always_false?.should be_false
-    end
-
-    it 'should return false when the queried power is not a scope, but returns nil' do
-      @user.power.always_nil?.should be_false
-    end
-
-  end
-
-  describe 'include!' do
-
-    it 'should raise Consul::Powerless when the given record belongs to a scope' do
-      expect { @user.power.client!(@deleted_client) }.to raise_error(Consul::Powerless)
-    end
-
-    it 'should not raise Consul::Powerless when the given record does not belong to a scope' do
-      expect { @user.power.client!(@client1) }.to_not raise_error
-    end
-
-    it 'should not raise Consul::Powerless when the queried power returns a scope (which might or might not match records)' do
-      expect { @user.power.clients! }.to_not raise_error
-    end
-
-    it 'should not raise Consul::Powerless when the queried power is not a scope, but returns true' do
-      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.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.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
-
-end

data/spec/controllers/users_controller_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe UsersController do
-
-  it "should raise an error if the checked power is not given" do
-    expect { get :update, :id => '1' }.to raise_error(Consul::Powerless)
-  end
-
-  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/support/spec.opts

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

data/spec/support/spec_candy.rb

@@ -1,179 +0,0 @@
-# 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