cantango 0.8.0

data/spec/cantango/license/save_license_spec.rb

@@ -0,0 +1,24 @@
+require 'rspec'
+require 'cantango'
+require 'rails'
+require 'require_all'
+
+DIR = File.dirname(__FILE__) 
+
+#require_all DIR + '/../../../app/models'
+
+describe 'Save License to yaml' do
+  pending 'not done'
+
+  before :each do
+    # @license = LicenseConfig.new :name => 'blogging'
+    # @license.can = PermissionSet.new :read => ['Article', 'Post']
+  end
+
+  # it "should save license to license.yml file" do
+  #   pending
+  #   puts @license
+  #   puts @license.to_yaml
+  # end
+end
+

data/spec/cantango/models/items.rb

@@ -0,0 +1,12 @@
+require 'active_record'
+class Comment < ActiveRecord::Base
+  belongs_to :user
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :user
+end
+
+class Article < ActiveRecord::Base
+  belongs_to :user
+end

data/spec/cantango/models/users.rb

@@ -0,0 +1,13 @@
+class User < ActiveRecord::Base  
+  include_and_extend SimpleRoles
+  
+  has_many :articles
+  has_many :comments
+  has_many :posts
+  has_many :accounts, :foreign_key => "account_id"
+end
+
+# should not inherit from AR, since no need to persist Guest 
+class Guest
+  # ???
+end

data/spec/cantango/moneta_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+require "moneta/adapters/memory"
+
+shared_examples_for "a read/write Moneta cache" do
+  types = {
+    "String" => ["key", "key2"],
+    "Object" => [{:foo => :bar}, {:bar => :baz}]
+  }
+
+  types.each do |type, (key, key2)|
+    it "reads from keys that are #{type}s like a Hash" do
+      @cache[key].should == nil
+    end
+  end
+end
+
+describe "Moneta::Adapters::Memory" do
+  #class EmptyMiddleware
+    #include Moneta::Middleware
+  #end
+
+  before(:each) do
+    @cache = Moneta::Builder.build do
+      run Moneta::Adapters::Memory
+    end
+    @cache.clear
+  end
+
+  it_should_behave_like "a read/write Moneta cache"
+end

data/spec/cantango/permission_engine/PERMISSION_STORE.textile

@@ -0,0 +1,75 @@
+h2. Permission store
+
+The Permission store is basically a key-value store. Each top level key is a type of permission:
+The types are:
+* roles
+* role_groups
+* licenses
+
+Note that licenses are just named subsets of rules and can thus be reused for oth roles and role_groups.
+
+roles:
+  blogger:
+    can:
+    cannot:
+    author:
+      Comment:
+        can:
+role_groups:
+  admins:
+    can:
+licenses:
+  editors:
+    can:
+
+If using a Yaml store, the default file name is: config/tango_permissions.yml
+
+h2. User Permission store
+
+stan@theman.com:
+  can:
+  cannot:
+  owner:
+    Comment:
+      can:
+
+If using a Yaml store, the default file name is: config/tango_user_permissions.yml
+
+h2. Categories store
+
+The categories store can be used to define categories of classes that can be acted upon in the same way.
+
+articles: [Blog, Post]
+roles: [Role, RoleGroup]
+
+If using a Yaml store, the default file name is: config/tango_categories.yml
+
+All access to a store must go through a CanTango::Permission::Store class.
+
+h2. Caching and loading
+
+When a store is loaded, all permissions are parsed and evaluated as CanCan rules and cached under the specific key.
+
+Cache
+  roles:
+    bloggers: [rules]
+  role_groups:
+    admins: [rules]
+
+CanTango.permission_store.cache(:roles).rules_for(:bloggers)
+
+When a store is saved, the Cache for that store must be invalidated and the rules rebuilt.
+
+CanTango.permission_store.save! permissions
+
+CanTango.permission_store.cache.invalidate!
+
+h2. Permissions
+
+CanTango::Permission uses a Hashie to store the rules
+
+* name
+* rules [Hashie]
+
+@stanislaw: let the name and #rules content will have string keys, not symbols.
+Hashie::Mash uses strings, and for us this convention is good for lib & spec stuff consistency.

data/spec/cantango/permission_engine/categories_store_spec.rb

@@ -0,0 +1,10 @@
+require 'rspec'
+require 'cantango'
+
+describe 'Categories store' do
+  # let (:categories_store) { CanTango.categories_store }
+    # its(:cache) { should_not be_nil}
+end
+
+
+

data/spec/cantango/permission_engine/compiler_spec.rb

@@ -0,0 +1,32 @@
+require 'rspec'
+require 'cantango'
+require 'hashie'
+def permission_fixture
+  group = 'bloggers'
+  rules = Hashie::Mash.new({"can"=>{"read"=>["Article", "Comment"]}, "cannot"=>{"write"=>["Article", "Post"]}})
+  CanTango::PermissionEngine::Parser::Permissions.new.parse(group, rules) do |permission|
+    return permission
+  end
+end
+
+describe CanTango::PermissionEngine::Compiler do
+  let (:permission) { permission_fixture }
+
+  let(:compiler) do 
+    compiler = CanTango::PermissionEngine::Compiler.new
+    compiler.compile! permission
+  end
+
+  it 'should produce cancan statements' do
+    compiler.can_eval do |statements|
+      statements.should == %|can(:read, Article)\ncan(:read, Comment)|
+    end
+  end
+
+  it 'should produce cancan statements' do
+    compiler.cannot_eval do |statements|
+      statements.should == %|cannot(:write, Article)\ncannot(:write, Post)|
+    end
+  end
+
+end

data/spec/cantango/permission_engine/loader/categories_spec.rb

@@ -0,0 +1,19 @@
+require 'rspec'
+require 'cantango'
+
+def config_folder 
+  File.dirname(__FILE__)+ "/../../../fixtures/config/"
+end
+
+describe 'Load Categories rules' do
+  let (:file) do
+    File.join(config_folder, 'categories.yml')
+  end
+
+  it "should load a categories file" do
+    loader = CanTango::PermissionEngine::Loader::Categories.new file
+   
+    loader.categories['user_models'].should include('Admin')
+    loader.categories['articles'].should include('Article')
+  end 
+end

data/spec/cantango/permission_engine/loader/permissions/cantango_permissions_loader.rb

@@ -0,0 +1,27 @@
+require 'rspec'
+require 'cantango' 
+$:.unshift File.dirname(__FILE__)
+require 'shared'
+
+describe 'Load Permissions file' do
+  let (:file) do
+    File.join(config_folder, 'cantango_permissions.yml')
+  end
+
+  let (:loader) { CanTango::PermissionEngine::Loader::Permissions.new file }
+
+  it_behaves_like "Permissions Loader"
+
+  it 'load roles permissions group' do
+    loader.roles_permissions.admin.static_rules.can.manage.first.should == 'all'
+  end
+
+  it 'load role_groups permissions group' do
+    loader.role_groups_permissions.bloggers.static_rules.can.read.first.should == 'Article'
+  end
+
+  it 'load licenses permissions group' do
+    loader.licenses_permissions.editors.static_rules.can.manage.should == ['all']
+  end
+
+end

data/spec/cantango/permission_engine/loader/permissions/shared.rb

@@ -0,0 +1,9 @@
+def config_folder 
+  File.dirname(__FILE__)+ "/../../../fixtures/config/"
+end
+
+shared_examples_for "Permissions Loader" do
+  it "should load a permission file" do
+    loader.permissions.should_not be_empty
+  end
+end

data/spec/cantango/permission_engine/parser_spec.rb

@@ -0,0 +1,39 @@
+require 'rspec'
+require 'cantango'
+
+describe CanTango::PermissionEngine::Parser do
+  context 'simple targets without categories' do
+    let (:parser) do
+      CanTango::Permission::Parser.new
+    end
+
+    let :targets do
+      ['all', 'Article', 'Comment']
+    end
+
+    it 'should parse targets' do
+      pending
+      #puts parser.parse(targets)
+    end
+  end
+
+  context 'targets using categories' do
+    let (:categories) do
+      cats = {:articles => ['Comment', 'Post']}
+      CanTango::Configuration::Categories.new :my_categories, cats
+    end
+
+    let (:parser) do
+      CanTango::PermissionEngine::Parser.new categories
+    end
+
+    let :targets do
+      ['all', '@articles']
+    end
+
+    it 'should parse targets' do
+      pending
+    end
+  end
+end
+

data/spec/cantango/permission_engine/permission_spec.rb

@@ -0,0 +1,35 @@
+require 'rspec'
+require 'cantango'
+require 'fixtures/models/items'
+
+describe CanTango::PermissionEngine::Permission do
+  before(:all) do
+    @permission = CanTango::PermissionEngine::Permission.new :bloggers
+  end
+
+  subject do 
+    reads = ['Article' , 'Comment']
+    writes = ['Article' , 'Post']
+    @permission.static_rules.can = {:read => reads}
+    @permission.static_rules.cannot = {:write => writes}
+    @permission
+  end
+
+  its(:name) { should == :bloggers }
+
+  context 'static rules' do
+    subject { @permission.static_rules} 
+    it { should include('can') }
+    its(:can) { should include('read')}
+    its(:cannot) { should include('write')}
+  end
+
+  context 'compiled rules' do
+    subject { @permission.compiled_rules} 
+    it { should include('can')}
+    it { should include('cannot')}
+    its(:can) { should == %|can(:read, Article)\ncan(:read, Comment)|}
+    its(:cannot) { should == %|cannot(:write, Article)\ncannot(:write, Post)|}
+  end
+
+end

data/spec/cantango/permission_engine/permission_store_spec.rb

@@ -0,0 +1,10 @@
+require 'rspec'
+require 'cantango'
+
+describe 'Permission store' do
+  pending 'todo later'
+
+  let (:permission_store) { CanTango.permission_store}
+end
+
+

data/spec/cantango/permission_engine/shared_examples.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+shared_examples_for "Having permissions" do
+  it 'should contain bloggers permission allowing to read Comments' do
+    store.role_groups_permissions['bloggers'].static_rules.can.read.should include('Article')
+  end
+ 
+  it 'should contain editors permission allowing to write Posts' do
+    store.role_groups_permissions['editors'].static_rules.cannot.write.should include('Post')
+  end
+end
+
+shared_examples_for "Having compiled permissions" do
+  it 'should contain bloggers permission allowing to read Comments' do
+    store.role_groups_rules.bloggers.can.should == %|can(:read, Article)\ncan(:read, Comment)|
+  end
+ 
+  it 'should contain editors permission allowing to write Posts' do
+    store.role_groups_rules.editors.cannot.should == %|cannot(:write, Article)\ncannot(:write, Post)|
+  end
+end
+
+

data/spec/cantango/permission_engine/store_spec.rb

@@ -0,0 +1,8 @@
+require 'rspec'
+require 'cantango'
+
+describe CanTango::PermissionEngine::Store do
+  let(:store) { CanTango::PermissionEngine::Store }
+  let (:permission_store) { CanTango.permission_store}
+end
+

data/spec/cantango/permission_engine/user_permission_store_spec.rb

@@ -0,0 +1,12 @@
+require 'rspec'
+require 'cantango'
+
+describe 'User permission store' do
+  pending 'todo later'
+
+  let (:user_permission_store) { CanTango.user_permission_store}
+end
+
+
+
+

data/spec/cantango/permission_engine/yaml_store_spec.rb

@@ -0,0 +1,83 @@
+$:.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'cantango'
+require 'fixtures/tango_fixtures'
+require 'fixtures/models/user'
+require 'fixtures/models/items'
+require 'shared_examples'
+
+def config_folder 
+  File.dirname(__FILE__)+ "/../../fixtures/config/"
+end
+
+describe CanTango::PermissionEngine::YamlStore do
+  include CanTangoFixtures
+  let (:permissions) { tango_permissions }
+  
+  context 'Loading permissions' do
+    let (:store) do
+      @store ||= CanTango::PermissionEngine::YamlStore.new 'cantango_permissions', :path => config_folder 
+    end
+    
+    before(:each) do
+      store.load!
+    end
+
+    it_should_behave_like "Having permissions"
+  end
+
+  context 'Caching permissions by types' do
+    let (:store) do
+      # filename: 'cantango_permissions.yml',
+      @store ||= CanTango::PermissionEngine::YamlStore.new 'cantango_permissions', :path => config_folder 
+    end
+
+    before(:each) do
+      store.load!
+    end
+
+    context "roles" do
+      subject{ @store.roles_rules }
+      it { should == @store.roles_compiled_permissions }
+    end
+
+    context "role groups" do
+      subject{ @store.role_groups_rules }
+      it { should == @store.role_groups_compiled_permissions }
+    end
+
+    context "licenses" do
+      subject{ @store.licenses_rules }
+      it { should == @store.licenses_compiled_permissions }
+    end
+
+    it_should_behave_like "Having compiled permissions"
+  end
+
+  context 'Saving permissions' do
+    let (:store) do
+      @store ||= CanTango::PermissionEngine::YamlStore.new :test_permissions, :path => config_folder 
+    end
+
+    before(:each) do
+      store.save! permissions
+      store.load!
+    end
+
+    it_should_behave_like "Having permissions" 
+  end
+
+  context 'Loading permissions and saving them again' do
+    let (:store) do
+      @store ||= CanTango::PermissionEngine::YamlStore.new :test_permissions, :path => config_folder 
+    end
+
+    before(:each) do
+      store.load!
+      store.save!
+      store.load!
+    end
+
+    it_should_behave_like "Having permissions"
+  end
+end