can_self_do_it 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in can_do_it.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,203 @@
+= can_self_do_it
+
+* http://github.com/mbuceta/can_self_o_it
+
+== Description:
+
+Generate a simple interface to works with users CRUD rights.
+
+
+== Features:
+
+* Allows check permissions for CRUD actions can_create?, can_see?, can_edit? and can_delete?
+* Allows check permissions for general actions responding to can_.+? regular expresion
+* Add an interface for known users with a default implementation of the CRUD action permissions.
+* Add an interface for unknown users with a default implementation of the CRUD action permissions.
+* Allows add custom behaviors for especific objects instead of the default implementation
+
+== Synopsis:
+
+Despite the fact that this gems hasn't any dependency with others gems, it arises from the double
+permission checking in rails.  We have to check action rights in controllers, and in the other hand
+we have to check rights to show actions in views.
+
+This gem allows you to add the permission logic in one place and use it in both, views and controllers.
+Also, this gem add default behaviors for common cases. And overwrite the default behavior using  custom
+implementations.
+
+== Basic usage in a Rails app:
+
+=== Model:
+
+ class Post
+ ...
+ end
+
+ # Represent an identified user of the application
+ class User
+  acts_as_can_self_do_it(:as => CanSelfDoIt::Known)
+  ...
+ end
+
+=== View:
+
+  link_to('edit',   @post) if session_user.user.can_edit?(@post)
+  link_to('delete', @post) if session_user.user.can_delete?(@post)
+
+=== Controller:
+
+ before_filter :check_post_edition_rights, :only => :edit
+ ....
+ private
+
+  def check_post_edition_rights
+    render(:status => :unauthorized) unless session_user.can_edit?(@post)
+  end
+
+
+==  Complete usage example:
+
+=== Application permissions management
+
+Module for custom permissions for Guest (unknown user)
+
+  module GuestCustomPermissions
+   # Ovewrite default CanSelfDoIt::Unknown implementation.
+   # Guest only can see admin comments.
+   # This method overrides
+   # can_see? method for objects of Comment class.
+   # i.e. this method is called when can_see?(comment) is
+   # called and comment is a Comment
+   def can_see_comment?(comment); comment.user.admin?; end
+  end
+
+Module for custom permissions for User (known user)
+
+  module UserCustomPermissions
+    # CanSelfDoIt::Known check this method for default implementation.
+    def admin?; false;end
+
+    # Ovewrite default CanSelfDoIt::Known implementation
+    # Users can comment any post
+    # This method overrides
+    # can_create? method for objects of Comment class.
+    # i.e. this method is called when can_create?(Comment, post)
+    # The post param is the post in which the comment will be written
+    def can_create_comment?(post); true; end
+  end
+
+Module for custom permissions for Admin (admin like user)
+
+  module AdminCustomPermissions
+    # CanSelfDoIt::Known check this method for default implementation.
+    def admin?; true;end
+  end
+
+=== Application classes
+
+  # Represent an unidentified user of the application
+  class Guest
+    acts_as_can_self_do_it(:as => [CanSelfDoIt::Unknown, GuestCustomPermissions])
+    ...
+  end
+
+  # Represent an identified user of the application
+  class User
+    acts_as_can_self_do_it(:as => [CanSelfDoIt::Known, UserCustomPermissions])
+    attr_accessor :blogs
+    ...
+  end
+
+  # Represent the application admin
+  class Admin
+    acts_as_can_self_do_it(:as => [CanSelfDoIt::Known, AdminCustomPermissions])
+    attr_accessor :blogs
+    ...
+  end
+
+  # A simple Blog + Post + Comment app
+  class Blog
+    attr_accessor :user, :posts
+    ...
+  end
+
+  class Post
+    attr_accessor :blog, :comments, :user
+    ...
+  end
+
+  class Comment
+    attr_accessor :post, :user
+    ...
+  end
+
+=== CanSelfDoIt working
+
+
+Working for an instance of Admin
+
+  an_admin.can_see?(admin_blog).should_be true
+  an_admin.can_see?(other_user_blog).should_be true
+  an_admin.can_edit?(admin_blog).should_be true
+  an_admin.can_edit?(other_user_blog).should_be true
+  an_admin.can_create?(Post, admin_blog).should_be true
+  an_admin.can_create?(Post, other_user_blog).should_be true
+
+Working for an instance of User
+
+  an_user.can_see?(user_blog).should_be true
+  an_user.can_see?(other_user_blog).should_be true
+  an_user.can_edit?(user_blog).should_be true
+  an_user.can_edit?(other_user_blog).should_be false
+  an_user.can_create?(Post, user_blog).should_be true
+  an_user.can_create?(Post, other_user_blog).should_be false
+  # Custom
+  an_user.can_create?(Comment, user_post).should_be true
+  an_user.can_create?(Comment, other_user_post).should_be true
+
+Working for an instance of Guest
+  a_guest.can_see?(user_blog).should_be true
+  a_guest.can_see?(user_post).should_be true
+  a_guest.can_edit?(user_blog).should_be false
+  a_guest.can_edit?(user_post).should_be false
+  a_guest.can_create?(Post, user_blog).should_be false
+  a_guest.can_create?(Comment, user_post).should_be false
+  # Custom
+  a_guest.can_see?(user_comment).should_be false
+  a_guest.can_see?(admin_comment).should_be true
+
+
+
+== Requirements:
+
+This gems hasn't dependencies
+
+
+== Install:
+
+sudo gem install can_self_do_it
+
+== License:
+
+(The MIT License)
+
+Copyright (c) 2013 Juan Martin Buceta
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -I lib -r can_do_it.rb"
+end
+
+task :default => :spec
+task :test => :spec

data/can_self_do_it.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "can_self_do_it/version"
+
+Gem::Specification.new do |s|
+  s.name        = "can_self_do_it"
+  s.version     = CanSelfDoIt::VERSION
+  s.authors     = ["Juan Martín Buceta"]
+  s.email       = ["mbuceta@grantaire.com.ar"]
+  s.homepage    = "http://martinbuceta.com.ar"
+  s.summary     = %q{Simple can_*? like method to manage permissions}
+  s.description = %q{Provide modules to work with sereveral permission policies}
+
+  s.rubyforge_project = "can_self_do_it"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/can_self_do_it/auto.rb

@@ -0,0 +1,39 @@
+require 'can_self_do_it/helper'
+module CanSelfDoIt
+module Auto
+
+  # Automatic method generation.
+  # Everything defined as /can_.+\?/ that does not exists get name from param type
+  # i.e methods like can_do_something?(project) => can_do_something_project
+  def method_missing(symbol, *args, &block)
+    if symbol.to_s == 'can_modify_default?'
+      raise NotImplementedError.new("You must implement can_modify_default?.")
+    elsif can_self_do_it_method?(symbol)
+      raise ArgumentError, "wrong number of arguments(#{args.size}1 for 1)"  unless args.size == 1
+      obj = args[0]
+      new_symbol = "#{symbol.to_s[0..-2]}_#{CanSelfDoIt::Helper.class_2_method_sub_str(obj.class)}?"
+      respond_to_without_can_self_do_it_method?(new_symbol) ? send(new_symbol, obj) : can_modify_default?(obj)
+    else
+      super
+    end
+  end
+
+
+  def respond_to_with_can_self_do_it_method?(*args)
+    can_self_do_it_method?(*args) || respond_to_without_can_self_do_it_method?(*args)
+  end
+
+  alias_method :respond_to?, :respond_to_with_can_self_do_it_method?
+
+  protected
+
+  def can_modify_default?(obj);  raise NotImplementedError.new("You must implement can_modify_default?.") ; end
+
+  private
+
+  def can_self_do_it_method?(symbol)
+     !!(symbol.to_s =~ /^can_.+\?/ )
+  end
+
+end
+end

data/lib/can_self_do_it/base.rb

@@ -0,0 +1,40 @@
+require 'can_self_do_it/helper'
+module CanSelfDoIt
+module Base
+
+  def can_see?(obj)
+    method = "can_see_#{CanSelfDoIt::Helper.class_2_method_sub_str(obj.class)}?"
+    respond_to_without_can_self_do_it_method?(method) ?  self.send(method,obj) : can_see_default?(obj)
+  end
+
+  def can_edit?(obj)
+    method = "can_edit_#{CanSelfDoIt::Helper.class_2_method_sub_str(obj.class)}?"
+    respond_to_without_can_self_do_it_method?(method) ?  send(method,obj) : can_edit_default?(obj)
+  end
+
+  # parent: parent of the object created
+  # Examples:
+  # - session_user.can_create?(Proposal, project)
+  # - session_user.can_create?(Project)
+  def can_create?(obj_class, parent = self)
+    method = "can_create_#{CanSelfDoIt::Helper.class_2_method_sub_str(obj_class)}?"
+    respond_to_without_can_self_do_it_method?(method) ?  send(method,parent) : can_create_default?(parent)
+  end
+
+  def can_delete?(obj)
+    method = "can_delete_#{CanSelfDoIt::Helper.class_2_method_sub_str(obj.class)}?"
+    respond_to_without_can_self_do_it_method?(method) ?  send(method,obj) : can_delete_default?(obj)
+  end
+
+  alias_method :respond_to_without_can_self_do_it_method?, :respond_to?
+
+protected
+
+  def can_see_default?(obj);           raise NotImplementedError.new("You must implement can_see_default?.")    ; end
+  def can_edit_default?(obj);          raise NotImplementedError.new("You must implement can_edit_default?.")   ; end
+  def can_create_default?(parent);     raise NotImplementedError.new("You must implement can_create_default?.") ; end
+  def can_delete_default?(obj);        raise NotImplementedError.new("You must implement can_delete_default?.") ; end
+
+
+end
+end

data/lib/can_self_do_it/helper.rb

@@ -0,0 +1,27 @@
+module CanSelfDoIt
+module Helper
+
+  def self.class_2_method_sub_str(a_class)
+    str = a_class.to_s
+    str.respond_to?(:underscore) ?  str.underscore.sub('/','__') : self.underscore(str).sub('/','__')
+  end
+
+  def self.underscore(camel_cased_word)
+    word = camel_cased_word.to_s.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/(?:([A-Za-z\d])|^)(#{/(?=a)b/})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
+    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+
+  def self.camelize(string)
+    string.sub(/^[a-z\d]*/){$&.capitalize}.gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}"}.gsub('/', '::')
+  end
+
+end
+end
+
+

data/lib/can_self_do_it/known.rb

@@ -0,0 +1,44 @@
+module CanSelfDoIt
+module Known
+
+protected
+
+  def can_see_default?(obj); true; end
+
+  # Check for can_modify_default
+  def can_edit_default?(obj); can_modify_default?(obj); end
+
+  # Check the parent owner of the object to create
+  def can_create_default?(parent); can_modify_default?(parent); end
+
+  # Check for can_modify_default
+  def can_delete_default?(obj); can_modify_default?(obj); end
+
+  # Check if self is the administration or the obj owner
+  def can_modify_default?(obj); administrator_or_object_owner?(obj); end
+
+
+  def owner_method_names
+    [:owner, :author, :user]
+  end
+
+  def admin_method_name
+    :admin?
+  end
+
+
+private
+
+  def administrator_or_object_owner?(obj)
+    !! (
+         (self.admin_method_name && self.respond_to?(admin_method_name) && self.send(admin_method_name)) || #Administrator
+          self == owner_for(obj))
+  end
+
+  #we are finding object owner
+  def owner_for(obj)
+    (obj.is_a?(self.class) && obj) || (owner_method = owner_method_names.detect{|n| obj.respond_to?(n)}) && obj.send(owner_method)
+  end
+
+end
+end

data/lib/can_self_do_it/unknown.rb

@@ -0,0 +1,18 @@
+module CanSelfDoIt
+module Unknown
+
+protected
+
+  def can_see_default?(obj);        true;  end
+
+  def can_edit_default?(obj);       can_modify_default?(obj); end
+
+  def can_create_default?(parent);  can_modify_default?(parent); end
+
+  def can_delete_default?(obj);     can_modify_default?(obj); end
+
+  def can_modify_default?(obj);     false; end
+
+
+end
+end

data/lib/can_self_do_it/version.rb

@@ -0,0 +1,3 @@
+module CanSelfDoIt
+  VERSION = "0.0.1"
+end

data/lib/can_self_do_it.rb

@@ -0,0 +1,22 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "can_self_do_it/version"
+require "can_self_do_it/base"
+require "can_self_do_it/auto"
+require "can_self_do_it/known"
+require "can_self_do_it/unknown"
+
+module CanSelfDoIt
+  # Your code goes here...
+end
+
+Module.class_eval do
+  def acts_as_can_self_do_it(options={})
+    self.send(:include,  CanSelfDoIt::Base)
+    self.send(:include,  CanSelfDoIt::Auto) if options[:auto]
+    as = options[:as] || []
+    as = [as] unless as.respond_to?(:each)
+    as.each{|m| self.send(:include,  m)}
+  end
+end

data/spec/admin_spec.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Admin do
+
+  before(:all) do
+   # Admin Blogs and Posts
+   class AdminActsAsCanSelfDoIt < Admin
+     acts_as_can_self_do_it(:as => CanSelfDoIt::Known, :auto => false)
+   end
+   @admin      = AdminActsAsCanSelfDoIt.new
+   @blog_admin = Blog.new(@admin)
+   @post_admin = Post.new(@blog_admin)
+   # User Blogs and Posts
+   @user      = User.new
+   @blog_user = Blog.new(@user)
+   @post_user = Post.new(@blog_user)
+  end
+
+  it "can see any Blog" do
+    @admin.can_see?(@blog_admin).should == true
+    @admin.can_see?(@blog_user).should  == true
+  end
+
+  it "can see any Post" do
+    @admin.can_see?(@post_admin).should == true
+    @admin.can_see?(@post_user).should  == true
+  end
+
+
+  it "can edit any Blog" do
+    @admin.can_edit?(@blog_admin).should == true
+    @admin.can_edit?(@blog_user).should  == true
+  end
+
+  it "can edit any Post" do
+    @admin.can_edit?(@post_admin).should == true
+    @admin.can_edit?(@post_user).should  == true
+  end
+
+  it "can comment any Post" do
+    @admin.can_create?(Comment, @post_admin).should == true
+    @admin.can_create?(Comment, @post_user).should  == true
+  end
+
+  it "can delete any Blog" do
+    @admin.can_delete?(@blog_admin).should == true
+    @admin.can_delete?(@blog_user).should  == true
+  end
+
+  it "can delete any Post" do
+    @admin.can_delete?(@post_admin).should == true
+    @admin.can_delete?(@post_user).should  == true
+  end
+
+end

data/spec/auto_admin_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Admin do
+
+  before(:all) do
+   # Admin Blogs and Posts
+   class AutoAdminActsAsCanSelfDoIt < Admin
+     acts_as_can_self_do_it(:as => CanSelfDoIt::Known, :auto => true)
+   end
+
+   @admin      = AutoAdminActsAsCanSelfDoIt.new
+   @blog_admin = Blog.new(@admin)
+   @post_admin = Post.new(@blog_admin)
+   # User Blogs and Posts
+   @user      = User.new
+   @blog_user = Blog.new(@user)
+   @post_user = Post.new(@blog_user)
+  end
+
+  it "can see any Blog" do
+    @admin.can_see?(@blog_admin).should == true
+    @admin.can_see?(@blog_user).should  == true
+  end
+
+  it "can see any Post" do
+    @admin.can_see?(@post_admin).should == true
+    @admin.can_see?(@post_user).should  == true
+  end
+
+
+  it "can edit any Blog" do
+    @admin.can_edit?(@blog_admin).should == true
+    @admin.can_edit?(@blog_user).should  == true
+  end
+
+  it "can edit any Post" do
+    @admin.can_edit?(@post_admin).should == true
+    @admin.can_edit?(@post_user).should  == true
+  end
+
+  it "can comment any Post" do
+    @admin.can_create?(Comment, @post_admin).should == true
+    @admin.can_create?(Comment, @post_user).should  == true
+  end
+
+  it "can delete any Blog" do
+    @admin.can_delete?(@blog_admin).should == true
+    @admin.can_delete?(@blog_user).should  == true
+  end
+
+  it "can delete any Post" do
+    @admin.can_delete?(@post_admin).should == true
+    @admin.can_delete?(@post_user).should  == true
+  end
+
+  it "can share any Blog" do
+    @admin.can_share?(@blog_admin).should == true
+    @admin.can_share?(@blog_user).should  == true
+  end
+
+  it "can join any Post" do
+    @admin.can_share?(@post_admin).should == true
+    @admin.can_share?(@post_user).should  == true
+  end
+
+end

data/spec/auto_guest_spec.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Guest do
+
+  before(:all) do
+
+    class GuestActsAsCanSelfDoIt < Guest
+      acts_as_can_self_do_it(:as => CanSelfDoIt::Unknown, :auto => true)
+    end
+
+    @guest = GuestActsAsCanSelfDoIt.instance
+
+    # Admin Blogs and Posts
+    @admin      = Admin.new
+    @blog_admin = Blog.new(@admin)
+    @post_admin = Post.new(@blog_admin)
+    # User Blogs and Posts
+    @user      = User.new
+    @blog_user = Blog.new(@user)
+    @post_user = Post.new(@blog_user)
+
+    @comment_user  = Comment.new(@post_admin, @user)
+    @comment_admin = Comment.new(@post_user, @admin)
+  end
+
+  it "can see any Blog" do
+    @guest.can_see?(@blog_admin).should == true
+    @guest.can_see?(@blog_user).should  == true
+  end
+
+  it "can see any Post" do
+    @guest.can_see?(@post_admin).should == true
+    @guest.can_see?(@post_user).should  == true
+  end
+
+  it "can't edit Blogs" do
+    @guest.can_edit?(@blog_admin).should == false
+    @guest.can_edit?(@blog_user).should  == false
+  end
+
+  it "can't edit Posts" do
+    @guest.can_edit?(@post_admin).should == false
+    @guest.can_edit?(@post_user).should  == false
+  end
+
+  it "can't delete Blogs" do
+    @guest.can_delete?(@blog_admin).should == false
+    @guest.can_delete?(@blog_user).should  == false
+  end
+
+  it "can't delete Posts" do
+    @guest.can_delete?(@post_admin).should == false
+    @guest.can_delete?(@post_user).should  == false
+  end
+
+  it "can't see user comments" do
+    @guest.can_see?(@comment_user).should == false
+  end
+
+  it "can see admin comments" do
+    @guest.can_see?(@comment_admin).should == true
+  end
+
+  it "can't share Posts" do
+    @guest.can_share?(@post_admin).should == false
+    @guest.can_share?(@post_user).should  == false
+  end
+
+  it "can't join to Blogs" do
+    @guest.can_join?(@blog_admin).should == false
+    @guest.can_join?(@blog_user).should  == false
+  end
+
+end

data/spec/auto_spec.rb

@@ -0,0 +1,57 @@
+describe CanSelfDoIt::Auto do
+
+  before(:all) do
+    class CanSelfDoItImpWithAuto; acts_as_can_self_do_it(:auto => true); end
+  end
+
+  it "must respond to can_see?" do
+    can_self_do_it_impl = CanSelfDoItImpWithAuto.new
+    can_self_do_it_impl.respond_to?(:can_see?).should  == true
+  end
+
+  it "must raise NotImplementedError when call can_see?" do
+    can_self_do_it_impl = CanSelfDoItImpWithAuto.new
+    expect{can_self_do_it_impl.can_see?(nil)}.to raise_error(NotImplementedError)
+  end
+
+  it "must respond to can_view?" do
+    can_self_do_it_impl = CanSelfDoItImpWithAuto.new
+    can_self_do_it_impl.respond_to?(:can_view?).should  == true
+  end
+
+  it "must raise NotImplementedError when call can_view?" do
+    can_self_do_it_impl = CanSelfDoItImpWithAuto.new
+    expect{can_self_do_it_impl.can_view?(nil)}.to raise_error(NotImplementedError)
+  end
+
+  it "must respond to can_eliminate?" do
+    can_self_do_it_impl = CanSelfDoItImpWithAuto.new
+    can_self_do_it_impl.respond_to?(:can_eliminate?).should  == true
+  end
+
+  it "must raise NotImplementedError when call can_eliminate?" do
+    can_self_do_it_impl = CanSelfDoItImpWithAuto.new
+    expect{can_self_do_it_impl.can_eliminate?(nil)}.to raise_error(NotImplementedError)
+  end
+
+  it "mustn't respond to eliminate?" do
+    can_self_do_it_impl = CanSelfDoItImpWithAuto.new
+    can_self_do_it_impl.respond_to?(:eliminate?).should  == false
+  end
+
+  it "must raise NoMethodError when call eliminate?" do
+    can_self_do_it_impl = CanSelfDoItImpWithAuto.new
+    expect{can_self_do_it_impl.eliminate?(nil)}.to raise_error(NoMethodError)
+  end
+
+  it "mustn't respond to can_eliminate" do
+    can_self_do_it_impl = CanSelfDoItImpWithAuto.new
+    can_self_do_it_impl.respond_to?(:can_eliminate).should  == false
+  end
+
+  it "must raise NoMethodError when call can_eliminate" do
+    can_self_do_it_impl = CanSelfDoItImpWithAuto.new
+    expect{can_self_do_it_impl.can_eliminate(nil)}.to raise_error(NoMethodError)
+  end
+
+end

data/spec/auto_user_spec.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe User do
+
+  before(:all) do
+   # User
+   class AutoUserActsAsCanSelfDoIt < User
+     acts_as_can_self_do_it(:as => CanSelfDoIt::Known, :auto => true)
+   end
+
+   @user      = AutoUserActsAsCanSelfDoIt.new
+
+   # User Blogs and Posts
+   @blog_user = Blog.new(@user)
+   @post_user = Post.new(@blog_user)
+
+   # Other User Blogs and Posts
+   @blog_other_user = Blog.new(User.new)
+   @post_other_user = Post.new(@blog_other_user)
+
+   # Admin Blogs and Posts
+   @blog_admin = Blog.new(Admin.new)
+   @post_admin = Post.new(@blog_admin)
+  end
+
+  it "can see any Blog" do
+    @user.can_see?(@blog_admin).should      == true
+    @user.can_see?(@blog_user).should       == true
+    @user.can_see?(@blog_other_user).should  == true
+  end
+
+  it "can see any Post" do
+    @user.can_see?(@post_admin).should      == true
+    @user.can_see?(@post_user).should       == true
+    @user.can_see?(@post_other_user).should  == true
+  end
+
+
+  it "can edit his Blogs" do
+    @user.can_edit?(@blog_user).should == true
+  end
+
+  it "can edit his Posts" do
+    @user.can_edit?(@post_user).should == true
+  end
+
+
+  it "can't edit other's Blogs" do
+    @user.can_edit?(@blog_admin).should      == false
+    @user.can_edit?(@blog_other_user).should == false
+  end
+
+  it "can't edit other's Posts" do
+    @user.can_edit?(@post_admin).should      == false
+    @user.can_edit?(@post_other_user).should == false
+  end
+
+  it "can comment his own posts" do
+    @user.can_create?(Comment, @user_post).should  == true
+  end
+
+  it "can comment other user posts" do
+    @user.can_create?(Comment, @other_user_post).should  == true
+  end
+
+  it "can comment admin posts" do
+    @user.can_create?(Comment, @other_user_post).should  == true
+  end
+
+  it "can delete his Blogs" do
+    @user.can_delete?(@blog_user).should == true
+  end
+
+  it "can delete his Posts" do
+    @user.can_delete?(@post_user).should == true
+  end
+
+  it "can't delete other's Blogs" do
+    @user.can_delete?(@blog_admin).should      == false
+    @user.can_delete?(@blog_other_user).should == false
+  end
+
+  it "can't delete other's Posts" do
+    @user.can_delete?(@post_admin).should      == false
+    @user.can_delete?(@post_other_user).should == false
+  end
+
+  it "can share his Posts" do
+    @user.can_share?(@post_user).should == true
+  end
+
+  it "can't share other's Blogs" do
+    @user.can_share?(@blog_admin).should      == false
+    @user.can_share?(@blog_other_user).should == false
+  end
+
+end

data/spec/base_spec.rb

@@ -0,0 +1,67 @@
+describe CanSelfDoIt::Base do
+
+  before(:all) do
+    class CanSelfDoItImp; acts_as_can_self_do_it; end
+  end
+
+  it "must respond to can_see?" do
+    can_self_do_it_impl = CanSelfDoItImp.new
+    can_self_do_it_impl.respond_to?(:can_see?).should  == true
+  end
+
+  it "must respond to can_edit?" do
+    can_self_do_it_impl = CanSelfDoItImp.new
+    can_self_do_it_impl.respond_to?(:can_edit?).should  == true
+  end
+
+  it "must respond to can_delete?" do
+    can_self_do_it_impl = CanSelfDoItImp.new
+    can_self_do_it_impl.respond_to?(:can_delete?).should  == true
+  end
+
+  it "must respond to can_create?" do
+    can_self_do_it_impl = CanSelfDoItImp.new
+    can_self_do_it_impl.respond_to?(:can_create?).should  == true
+  end
+
+  it "must raise NotImplementedError when call can_see?" do
+    can_self_do_it_impl = CanSelfDoItImp.new
+    expect{can_self_do_it_impl.can_see?(nil)}.to raise_error(NotImplementedError)
+  end
+
+  it "must raise NotImplementedError when call can_edit?" do
+    can_self_do_it_impl = CanSelfDoItImp.new
+    expect{can_self_do_it_impl.can_edit?(nil)}.to raise_error(NotImplementedError)
+  end
+
+  it "must raise NotImplementedError when call can_delete?" do
+    can_self_do_it_impl = CanSelfDoItImp.new
+    expect{can_self_do_it_impl.can_delete?(nil)}.to raise_error(NotImplementedError)
+  end
+
+  it "must raise NotImplementedError when call  can_create?" do
+    can_self_do_it_impl = CanSelfDoItImp.new
+    expect{can_self_do_it_impl.can_create?(nil,nil)}.to raise_error(NotImplementedError)
+  end
+
+  it "mustn't respond to can_view?" do
+    can_self_do_it_impl = CanSelfDoItImp.new
+    can_self_do_it_impl.respond_to?(:can_view?).should  == false
+  end
+
+  it "must raise NoMethodError when call can_view?" do
+    can_self_do_it_impl = CanSelfDoItImp.new
+    expect{can_self_do_it_impl.can_view?(nil)}.to raise_error(NoMethodError)
+  end
+
+  it "mustn't respond to can_eliminate?" do
+    can_self_do_it_impl = CanSelfDoItImp.new
+    can_self_do_it_impl.respond_to?(:can_eliminate?).should  == false
+  end
+
+  it "must raise NoMethodError when call can_eliminate?" do
+    can_self_do_it_impl = CanSelfDoItImp.new
+    expect{can_self_do_it_impl.can_eliminate?(nil)}.to raise_error(NoMethodError)
+  end
+
+end

data/spec/guest_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Guest do
+
+  before(:all) do
+
+    class GuestActsAsCanSelfDoIt < Guest
+      acts_as_can_self_do_it(:as => CanSelfDoIt::Unknown, :auto => false)
+    end
+
+    @guest = GuestActsAsCanSelfDoIt.instance
+
+    # Admin Blogs and Posts
+    @admin      = Admin.new
+    @blog_admin = Blog.new(@admin)
+    @post_admin = Post.new(@blog_admin)
+    # User Blogs and Posts
+    @user      = User.new
+    @blog_user = Blog.new(@user)
+    @post_user = Post.new(@blog_user)
+
+    @comment_user  = Comment.new(@post_admin, @user)
+    @comment_admin = Comment.new(@post_user, @admin)
+  end
+
+  it "can see any Blog" do
+    @guest.can_see?(@blog_admin).should == true
+    @guest.can_see?(@blog_user).should  == true
+  end
+
+  it "can see any Post" do
+    @guest.can_see?(@post_admin).should == true
+    @guest.can_see?(@post_user).should  == true
+  end
+
+  it "can't edit Blogs" do
+    @guest.can_edit?(@blog_admin).should == false
+    @guest.can_edit?(@blog_user).should  == false
+  end
+
+  it "can't edit Posts" do
+    @guest.can_edit?(@post_admin).should == false
+    @guest.can_edit?(@post_user).should  == false
+  end
+
+  it "can't delete Blogs" do
+    @guest.can_delete?(@blog_admin).should == false
+    @guest.can_delete?(@blog_user).should  == false
+  end
+
+  it "can't delete Posts" do
+    @guest.can_delete?(@post_admin).should == false
+    @guest.can_delete?(@post_user).should  == false
+  end
+
+  it "can't see user comments" do
+    @guest.can_see?(@comment_user).should == false
+  end
+
+  it "can see admin comments" do
+    @guest.can_see?(@comment_admin).should == true
+  end
+
+
+
+end

data/spec/known_spec.rb

@@ -0,0 +1,31 @@
+describe CanSelfDoIt::Known do
+
+  it "must implement can_see_default?" do
+    CanSelfDoIt::Known.protected_method_defined?(:can_see_default?).should  == true
+  end
+
+  it "must implement can_edit_default?" do
+    CanSelfDoIt::Known.protected_method_defined?(:can_edit_default?).should  == true
+  end
+
+  it "must implement can_create_default?" do
+    CanSelfDoIt::Known.protected_method_defined?(:can_create_default?).should  == true
+  end
+
+  it "must implement can_delete_default?" do
+    CanSelfDoIt::Known.protected_method_defined?(:can_delete_default?).should  == true
+  end
+
+  it "must implement can_modify_default?" do
+    CanSelfDoIt::Known.protected_method_defined?(:can_modify_default?).should  == true
+  end
+
+  it "must implement owner_method_names" do
+    CanSelfDoIt::Known.protected_method_defined?(:owner_method_names).should  == true
+  end
+
+  it "must implement admin_method_name" do
+    CanSelfDoIt::Known.protected_method_defined?(:admin_method_name).should  == true
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,77 @@
+require 'rubygems'
+require 'singleton'
+require 'rspec'
+require 'can_self_do_it'
+$LOAD_PATH.unshift File.expand_path("../lib", File.dirname(__FILE__))
+
+RSpec.configure do |config|
+ config.before :all do
+ end
+end
+
+class Guest
+ include Singleton
+  # Custom
+  # Guest only can see admin comments
+ def can_see_comment?(comment); comment.user.admin?; end
+end
+
+class User
+  attr_accessor :blogs
+  def admin?; false;end
+  def initialize
+    @blogs = []
+    self
+  end
+
+  # Custom
+  # Users can comment any post
+  def can_create_comment?(post); true; end
+
+end
+
+class Admin
+  attr_accessor :blogs
+  def admin?; true;end
+  def initialize
+    @blogs = []
+    self
+  end
+end
+
+
+class Blog
+  attr_accessor :user, :posts
+  def initialize(user)
+    @user = user
+    @posts = []
+    @user.blogs << self
+    self
+  end
+end
+
+class Post
+  attr_accessor :blog, :comments
+
+  def owner
+    @blog.user
+  end
+
+  def initialize(blog)
+    @comments = []
+    @blog = blog
+    @blog.posts << self
+    self
+  end
+end
+
+class Comment
+  attr_accessor :post, :user
+
+  def initialize(post, user)
+    @post = post
+    @user = user
+    @post.comments << self
+    self
+  end
+end

data/spec/unknown_spec.rb

@@ -0,0 +1,24 @@
+describe CanSelfDoIt::Unknown do
+
+  it "must implement can_see_default?" do
+    CanSelfDoIt::Unknown.protected_method_defined?(:can_see_default?).should  == true
+  end
+
+  it "must implement can_edit_default?" do
+    CanSelfDoIt::Unknown.protected_method_defined?(:can_edit_default?).should  == true
+  end
+
+  it "must implement can_create_default?" do
+    CanSelfDoIt::Unknown.protected_method_defined?(:can_create_default?).should  == true
+  end
+
+  it "must implement can_delete_default?" do
+    CanSelfDoIt::Unknown.protected_method_defined?(:can_delete_default?).should  == true
+  end
+
+  it "must implement can_modify_default?" do
+    CanSelfDoIt::Unknown.protected_method_defined?(:can_modify_default?).should  == true
+  end
+
+
+end

data/spec/user_spec.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe User do
+
+  before(:all) do
+   # User
+   class UserActsAsCanSelfDoIt < User
+     acts_as_can_self_do_it(:as => CanSelfDoIt::Known, :auto => false)
+   end
+
+   @user      = UserActsAsCanSelfDoIt.new
+
+   # User Blogs and Posts
+   @blog_user = Blog.new(@user)
+   @post_user = Post.new(@blog_user)
+
+   # Other User Blogs and Posts
+   @blog_other_user = Blog.new(User.new)
+   @post_other_user = Post.new(@blog_other_user)
+
+   # Admin Blogs and Posts
+   @blog_admin = Blog.new(Admin.new)
+   @post_admin = Post.new(@blog_admin)
+  end
+
+  it "can see any Blog" do
+    @user.can_see?(@blog_admin).should      == true
+    @user.can_see?(@blog_user).should       == true
+    @user.can_see?(@blog_other_user).should  == true
+  end
+
+  it "can see any Post" do
+    @user.can_see?(@post_admin).should      == true
+    @user.can_see?(@post_user).should       == true
+    @user.can_see?(@post_other_user).should  == true
+  end
+
+
+  it "can edit his Blogs" do
+    @user.can_edit?(@blog_user).should == true
+  end
+
+  it "can edit his Posts" do
+    @user.can_edit?(@post_user).should == true
+  end
+
+
+  it "can't edit other's Blogs" do
+    @user.can_edit?(@blog_admin).should      == false
+    @user.can_edit?(@blog_other_user).should == false
+  end
+
+  it "can't edit other's Posts" do
+    @user.can_edit?(@post_admin).should      == false
+    @user.can_edit?(@post_other_user).should == false
+  end
+
+  it "can comment his own posts" do
+    @user.can_create?(Comment, @user_post).should  == true
+  end
+
+  it "can comment other user posts" do
+    @user.can_create?(Comment, @other_user_post).should  == true
+  end
+
+  it "can comment admin posts" do
+    @user.can_create?(Comment, @other_user_post).should  == true
+  end
+
+  it "can delete his Blogs" do
+    @user.can_delete?(@blog_user).should == true
+  end
+
+  it "can delete his Posts" do
+    @user.can_delete?(@post_user).should == true
+  end
+
+  it "can't delete other's Blogs" do
+    @user.can_delete?(@blog_admin).should      == false
+    @user.can_delete?(@blog_other_user).should == false
+  end
+
+  it "can't delete other's Posts" do
+    @user.can_delete?(@post_admin).should      == false
+    @user.can_delete?(@post_other_user).should == false
+  end
+
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: can_self_do_it
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Juan Martín Buceta
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &8556920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *8556920
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &8556500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *8556500
+description: Provide modules to work with sereveral permission policies
+email:
+- mbuceta@grantaire.com.ar
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- can_self_do_it.gemspec
+- lib/can_self_do_it.rb
+- lib/can_self_do_it/auto.rb
+- lib/can_self_do_it/base.rb
+- lib/can_self_do_it/helper.rb
+- lib/can_self_do_it/known.rb
+- lib/can_self_do_it/unknown.rb
+- lib/can_self_do_it/version.rb
+- spec/admin_spec.rb
+- spec/auto_admin_spec.rb
+- spec/auto_guest_spec.rb
+- spec/auto_spec.rb
+- spec/auto_user_spec.rb
+- spec/base_spec.rb
+- spec/guest_spec.rb
+- spec/known_spec.rb
+- spec/spec_helper.rb
+- spec/unknown_spec.rb
+- spec/user_spec.rb
+homepage: http://martinbuceta.com.ar
+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: '0'
+requirements: []
+rubyforge_project: can_self_do_it
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Simple can_*? like method to manage permissions
+test_files: []