cancan-2 2.0.0.alpha

data/spec/cancan/model_adapters/default_adapter_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe CanCan::ModelAdapters::DefaultAdapter do
+  it "is default for generic classes" do
+    CanCan::ModelAdapters::AbstractAdapter.adapter_class(Object).should == CanCan::ModelAdapters::DefaultAdapter
+  end
+end

data/spec/cancan/model_adapters/mongoid_adapter_spec.rb

@@ -0,0 +1,227 @@
+if ENV["MODEL_ADAPTER"] == "mongoid"
+  require "spec_helper"
+
+  class MongoidCategory
+    include Mongoid::Document
+    references_many :mongoid_projects
+  end
+
+  class MongoidProject
+    include Mongoid::Document
+    referenced_in :mongoid_category
+  end
+
+  Mongoid.configure do |config|
+    config.master = Mongo::Connection.new('127.0.0.1', 27017).db("cancan_mongoid_spec")
+  end
+
+  describe CanCan::ModelAdapters::MongoidAdapter do
+    context "Mongoid defined" do
+      before(:each) do
+        @ability = Object.new
+        @ability.extend(CanCan::Ability)
+      end
+
+      after(:each) do
+        Mongoid.master.collections.select do |collection|
+          collection.name !~ /system/
+        end.each(&:drop)
+      end
+
+      it "is for only Mongoid classes" do
+        CanCan::ModelAdapters::MongoidAdapter.should_not be_for_class(Object)
+        CanCan::ModelAdapters::MongoidAdapter.should be_for_class(MongoidProject)
+        CanCan::ModelAdapters::AbstractAdapter.adapter_class(MongoidProject).should == CanCan::ModelAdapters::MongoidAdapter
+      end
+
+      it "finds record" do
+        project = MongoidProject.create
+        CanCan::ModelAdapters::MongoidAdapter.find(MongoidProject, project.id).should == project
+      end
+
+      it "compares properties on mongoid documents with the conditions hash" do
+        model = MongoidProject.new
+        @ability.can :read, :mongoid_projects, :id => model.id
+        @ability.should be_able_to(:read, model)
+      end
+
+      it "is able to read hashes when field is array" do
+        one_to_three = MongoidProject.create(:numbers => ['one', 'two', 'three'])
+        two_to_five  = MongoidProject.create(:numbers => ['two', 'three', 'four', 'five'])
+
+        @ability.can :foo, :mongoid_projects, :numbers => 'one'
+        @ability.should be_able_to(:foo, one_to_three)
+        @ability.should_not be_able_to(:foo, two_to_five)
+      end
+
+      it "returns [] when no ability is defined so no records are found" do
+        MongoidProject.create(:title => 'Sir')
+        MongoidProject.create(:title => 'Lord')
+        MongoidProject.create(:title => 'Dude')
+
+        MongoidProject.accessible_by(@ability, :read).entries.should == []
+      end
+
+      it "returns the correct records based on the defined ability" do
+        @ability.can :read, :mongoid_projects, :title => "Sir"
+        sir   = MongoidProject.create(:title => 'Sir')
+        lord  = MongoidProject.create(:title => 'Lord')
+        dude  = MongoidProject.create(:title => 'Dude')
+
+        MongoidProject.accessible_by(@ability, :read).entries.should == [sir]
+      end
+
+      it "returns the correct records when a mix of can and cannot rules in defined ability" do
+        pending "TODO figure out why this isn't working"
+        @ability.can :manage, :mongoid_projects, :title => 'Sir'
+        @ability.cannot :destroy, :mongoid_projects
+
+        sir   = MongoidProject.create(:title => 'Sir')
+        lord  = MongoidProject.create(:title => 'Lord')
+        dude  = MongoidProject.create(:title => 'Dude')
+
+        MongoidProject.accessible_by(@ability, :destroy).entries.should == [sir]
+      end
+
+      it "is able to mix empty conditions and hashes" do
+        pending "TODO figure out why this isn't working"
+        @ability.can :read, :mongoid_projects
+        @ability.can :read, :mongoid_projects, :title => 'Sir'
+        sir  = MongoidProject.create(:title => 'Sir')
+        lord = MongoidProject.create(:title => 'Lord')
+
+        MongoidProject.accessible_by(@ability, :read).count.should == 2
+      end
+
+      it "returns everything when the defined ability is access all" do
+        @ability.can :access, :all
+        sir   = MongoidProject.create(:title => 'Sir')
+        lord  = MongoidProject.create(:title => 'Lord')
+        dude  = MongoidProject.create(:title => 'Dude')
+
+        MongoidProject.accessible_by(@ability, :read).entries.should == [sir, lord, dude]
+      end
+
+      it "allows a scope for conditions" do
+        @ability.can :read, :mongoid_projects, MongoidProject.where(:title => 'Sir')
+        sir   = MongoidProject.create(:title => 'Sir')
+        lord  = MongoidProject.create(:title => 'Lord')
+        dude  = MongoidProject.create(:title => 'Dude')
+
+        MongoidProject.accessible_by(@ability, :read).entries.should == [sir]
+      end
+
+      describe "Mongoid::Criteria where clause Symbol extensions using MongoDB expressions" do
+        it "handles :field.in" do
+          obj = MongoidProject.create(:title => 'Sir')
+          @ability.can :read, :mongoid_projects, :title.in => ["Sir", "Madam"]
+          @ability.can?(:read, obj).should == true
+          MongoidProject.accessible_by(@ability, :read).should == [obj]
+
+          obj2 = MongoidProject.create(:title => 'Lord')
+          @ability.can?(:read, obj2).should == false
+        end
+
+        describe "activates only when there are Criteria in the hash" do
+          it "Calls where on the model class when there are criteria" do
+            obj = MongoidProject.create(:title => 'Bird')
+            @conditions = {:title.nin => ["Fork", "Spoon"]}
+
+            @ability.can :read, :mongoid_projects, @conditions
+            @ability.should be_able_to(:read, obj)
+          end
+          it "Calls the base version if there are no mongoid criteria" do
+            obj = MongoidProject.new(:title => 'Bird')
+            @conditions = {:id => obj.id}
+            @ability.can :read, :mongoid_projects, @conditions
+            @ability.should be_able_to(:read, obj)
+          end
+        end
+
+        it "handles :field.nin" do
+          obj = MongoidProject.create(:title => 'Sir')
+          @ability.can :read, :mongoid_projects, :title.nin => ["Lord", "Madam"]
+          @ability.can?(:read, obj).should == true
+          MongoidProject.accessible_by(@ability, :read).should == [obj]
+
+          obj2 = MongoidProject.create(:title => 'Lord')
+          @ability.can?(:read, obj2).should == false
+        end
+
+        it "handles :field.size" do
+          obj = MongoidProject.create(:titles => ['Palatin', 'Margrave'])
+          @ability.can :read, :mongoid_projects, :titles.size => 2
+          @ability.can?(:read, obj).should == true
+          MongoidProject.accessible_by(@ability, :read).should == [obj]
+
+          obj2 = MongoidProject.create(:titles => ['Palatin', 'Margrave', 'Marquis'])
+          @ability.can?(:read, obj2).should == false
+        end
+
+        it "handles :field.exists" do
+          obj = MongoidProject.create(:titles => ['Palatin', 'Margrave'])
+          @ability.can :read, :mongoid_projects, :titles.exists => true
+          @ability.can?(:read, obj).should == true
+          MongoidProject.accessible_by(@ability, :read).should == [obj]
+
+          obj2 = MongoidProject.create
+          @ability.can?(:read, obj2).should == false
+        end
+
+        it "handles :field.gt" do
+          obj = MongoidProject.create(:age => 50)
+          @ability.can :read, :mongoid_projects, :age.gt => 45
+          @ability.can?(:read, obj).should == true
+          MongoidProject.accessible_by(@ability, :read).should == [obj]
+
+          obj2 = MongoidProject.create(:age => 40)
+          @ability.can?(:read, obj2).should == false
+        end
+
+        it "handles instance not saved to database" do
+          obj = MongoidProject.new(:title => 'Sir')
+          @ability.can :read, :mongoid_projects, :title.in => ["Sir", "Madam"]
+          @ability.can?(:read, obj).should == true
+
+          # accessible_by only returns saved records
+          MongoidProject.accessible_by(@ability, :read).entries.should == []
+
+          obj2 = MongoidProject.new(:title => 'Lord')
+          @ability.can?(:read, obj2).should == false
+        end
+      end
+
+      it "calls where with matching ability conditions" do
+        obj = MongoidProject.create(:foo => {:bar => 1})
+        @ability.can :read, :mongoid_projects, :foo => {:bar => 1}
+        MongoidProject.accessible_by(@ability, :read).entries.first.should == obj
+      end
+
+      it "excludes from the result if set to cannot" do
+        obj = MongoidProject.create(:bar => 1)
+        obj2 = MongoidProject.create(:bar => 2)
+        @ability.can :read, :mongoid_projects
+        @ability.cannot :read, :mongoid_projects, :bar => 2
+        MongoidProject.accessible_by(@ability, :read).entries.should == [obj]
+      end
+
+      it "combines the rules" do
+        obj = MongoidProject.create(:bar => 1)
+        obj2 = MongoidProject.create(:bar => 2)
+        obj3 = MongoidProject.create(:bar => 3)
+        @ability.can :read, :mongoid_projects, :bar => 1
+        @ability.can :read, :mongoid_projects, :bar => 2
+        MongoidProject.accessible_by(@ability, :read).entries.should =~ [obj, obj2]
+      end
+
+      it "does not allow to fetch records when ability with just block present" do
+        @ability.can :read, :mongoid_projects do
+          false
+        end
+        lambda {
+          MongoidProject.accessible_by(@ability)
+        }.should raise_error(CanCan::Error)
+      end
+    end
+  end
+end

data/spec/cancan/rule_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+require "ostruct" # for OpenStruct below
+
+# Most of Rule functionality is tested in Ability specs
+describe CanCan::Rule do
+  before(:each) do
+    @conditions = {}
+    @rule = CanCan::Rule.new(true, :read, :integers, @conditions)
+  end
+
+  it "returns no association joins if none exist" do
+    @rule.associations_hash.should == {}
+  end
+
+  it "returns no association for joins if just attributes" do
+    @conditions[:foo] = :bar
+    @rule.associations_hash.should == {}
+  end
+
+  it "returns single association for joins" do
+    @conditions[:foo] = {:bar => 1}
+    @rule.associations_hash.should == {:foo => {}}
+  end
+
+  it "returns multiple associations for joins" do
+    @conditions[:foo] = {:bar => 1}
+    @conditions[:test] = {1 => 2}
+    @rule.associations_hash.should == {:foo => {}, :test => {}}
+  end
+
+  it "returns nested associations for joins" do
+    @conditions[:foo] = {:bar => {1 => 2}}
+    @rule.associations_hash.should == {:foo => {:bar => {}}}
+  end
+
+  it "returns no association joins if conditions is nil" do
+    rule = CanCan::Rule.new(true, :read, :integers)
+    rule.associations_hash.should == {}
+  end
+
+  it "has higher specificity for attributes/conditions" do
+    CanCan::Rule.new(true, :read, :integers).specificity.should eq(1)
+    CanCan::Rule.new(true, :read, :integers, :foo => :bar).specificity.should eq(2)
+    CanCan::Rule.new(true, :read, :integers, :foo).specificity.should eq(2)
+    CanCan::Rule.new(false, :read, :integers).specificity.should eq(3)
+    CanCan::Rule.new(false, :read, :integers, :foo => :bar).specificity.should eq(4)
+    CanCan::Rule.new(false, :read, :integers, :foo).specificity.should eq(4)
+  end
+
+  it "should not be mergeable if conditions are not simple hashes" do
+    meta_where = OpenStruct.new(:name => 'metawhere', :column => 'test')
+    @conditions[meta_where] = :bar
+    @rule.should be_unmergeable
+  end
+end

data/spec/matchers.rb

@@ -0,0 +1,13 @@
+RSpec::Matchers.define :orderlessly_match do |original_string|
+  match do |given_string|
+    original_string.split('').sort == given_string.split('').sort
+  end
+
+  failure_message_for_should do |given_string|
+    "expected \"#{given_string}\" to have the same characters as \"#{original_string}\""
+  end
+
+  failure_message_for_should_not do |given_string|
+    "expected \"#{given_string}\" not to have the same characters as \"#{original_string}\""
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require "sqlite3"
+require "active_record"
+
+case ENV["MODEL_ADAPTER"]
+when "data_mapper"
+  require "dm-core"
+  require "dm-sqlite-adapter"
+  require "dm-migrations"
+when "mongoid"
+  require "mongoid"
+end
+
+require 'active_support/all'
+require 'matchers'
+require 'cancan'
+require 'cancan/matchers'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end
+
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+  end
+end
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+class Category < ActiveRecord::Base
+  connection.create_table(table_name) do |t|
+    t.boolean :visible
+  end
+  has_many :projects
+end
+
+class Project < ActiveRecord::Base
+  connection.create_table(table_name) do |t|
+    t.integer :category_id
+    t.string :name
+  end
+  belongs_to :category
+end

metadata

@@ -0,0 +1,212 @@
+--- !ruby/object:Gem::Specification
+name: cancan-2
+version: !ruby/object:Gem::Version
+  version: 2.0.0.alpha
+  prerelease: 6
+platform: ruby
+authors:
+- Ryan Bates
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.6
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+- !ruby/object:Gem::Dependency
+  name: dm-core
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: dm-sqlite-adapter
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: dm-migrations
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.4.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.4.8
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+description: Simple authorization solution for Rails which is decoupled from user
+  roles. All permissions are stored in a single location.
+email: ryan@railscasts.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cancan/controller_resource.rb
+- lib/cancan/exceptions.rb
+- lib/cancan/rule.rb
+- lib/cancan/model_adapters/mongoid_adapter.rb
+- lib/cancan/model_adapters/active_record_adapter.rb
+- lib/cancan/model_adapters/default_adapter.rb
+- lib/cancan/model_adapters/abstract_adapter.rb
+- lib/cancan/model_adapters/data_mapper_adapter.rb
+- lib/cancan/ability.rb
+- lib/cancan/matchers.rb
+- lib/cancan/inherited_resource.rb
+- lib/cancan/controller_additions.rb
+- lib/cancan/model_additions.rb
+- lib/cancan.rb
+- lib/generators/cancan/ability/USAGE
+- lib/generators/cancan/ability/ability_generator.rb
+- lib/generators/cancan/ability/templates/ability_test.rb
+- lib/generators/cancan/ability/templates/ability.rb
+- lib/generators/cancan/ability/templates/ability_spec.rb
+- spec/cancan/controller_additions_spec.rb
+- spec/cancan/matchers_spec.rb
+- spec/cancan/inherited_resource_spec.rb
+- spec/cancan/controller_resource_spec.rb
+- spec/cancan/model_adapters/active_record_adapter_spec.rb
+- spec/cancan/model_adapters/default_adapter_spec.rb
+- spec/cancan/model_adapters/data_mapper_adapter_spec.rb
+- spec/cancan/model_adapters/mongoid_adapter_spec.rb
+- spec/cancan/exceptions_spec.rb
+- spec/cancan/rule_spec.rb
+- spec/cancan/ability_spec.rb
+- spec/README.rdoc
+- spec/spec_helper.rb
+- spec/matchers.rb
+- README.rdoc
+- Gemfile
+- Rakefile
+- CHANGELOG.rdoc
+- LICENSE
+- init.rb
+homepage: http://github.com/ryanb/cancan
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.4
+requirements: []
+rubyforge_project: cancan-2
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Simple authorization solution for Rails.
+test_files: []