reuser 1.0.0 → 2.0.0

data/lib/reuser/role.rb

@@ -1,46 +1,34 @@
-require_relative('../reuser')
-
 module ReUser
   class Role
-    def initialize(name)
-      @name = name
-      @actions = {}
-    end
+    attr_reader :name
 
-    def can(*names)
-      actions(*names)
+    def permissions
+      @permissions.keys
     end
 
-    def can?(name)
-      actions[name]
+    def initialize name, permissions=[]
+      @name = name
+      @permissions = {}
+      self.can *permissions
     end
 
-    def could(*names, &test)
-      names.each do |name|
-        action(name, test)
+    def can *permissions
+      permissions.each do |permission|
+        @permissions[permission] = lambda {|*args| true }
       end
     end
 
-    def could?(name, data)
-      if actions[name]
-        if actions[name].is_a?(Proc)
-          actions[name].call(data)
-        else
-          true
-        end
-      end
+    def can? permission
+      @permissions[permission].is_a? Proc
     end
 
-    private
-      def actions(*names)
-        names.each do |name|
-          action(name)
-        end
-        @actions
-      end
+    def could permission, &block
+      raise "#could requires a block" unless block_given?
+      @permissions[permission] = block
+    end
 
-      def action(name, test = true)
-        @actions[name] = test
-      end
+    def could? permission, block_args
+      @permissions[permission].call(block_args)
+    end
   end
 end

data/lib/reuser/version.rb

@@ -0,0 +1,6 @@
+module ReUser
+  MAJOR = 2
+  MINOR = 0
+  PATCH = 0
+  VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}"
+end

data/lib/reuser.rb

@@ -1,2 +1,37 @@
-require_relative(reuser_file = './reuser/reuser')
-require_relative(role_file = './reuser/role')
+require_relative "./reuser/role"
+
+module ReUser
+
+  def self.included klass
+
+    klass.instance_eval do
+      def roles &block
+        @@roles ||= {}
+        yield if block_given?
+        @@roles.freeze.keys
+      end
+
+      def role name, permissions=[], &block
+        role = ( @@roles[name] ||= ReUser::Role.new(name, permissions) )
+        yield(role) if block_given?
+        role
+      end
+    end
+  end
+
+  def can? permission
+    @role.can? permission
+  end
+
+  def cant? permission
+    !(can? permission)
+  end
+
+  def could? permission, block_args
+    @role.could? permission, block_args
+  end
+
+  def couldnt? permission, block_args
+    !(couldnt? permission, block_args)
+  end
+end

data/spec/reuser/class_spec.rb

@@ -0,0 +1,61 @@
+require_relative '../spec_helper'
+
+describe "Classes including ReUser" do
+  let(:klass) do
+    kls = Class.new
+    kls.instance_eval do
+      include ReUser
+
+      roles do
+        role(:admin)
+      end
+    end
+    kls
+  end
+  subject { klass }
+
+  context ".roles" do
+    it "optionally takes a block" do
+      lambda { subject.roles { :good } }.should_not raise_error
+      lambda { subject.roles }.should_not raise_error
+    end
+
+    it "returns an array of role names" do
+      subject.roles.should be_kind_of Array
+      subject.roles.all? {|el| el.is_a? Symbol}.should be_true
+    end
+  end
+
+  context ".role" do
+
+    it "takes a symbol" do
+      lambda { subject.role(:admin) }.should_not raise_error
+    end
+
+    it "takes a symbol, and an optional array" do
+      lambda { subject.role(:admin, [:read, :write]) }.should_not raise_error
+    end
+
+    it "returns a ReUser::Role instance" do
+      subject.role(:admin).should be_instance_of ReUser::Role
+    end
+
+    context "passing in a role that is already defined" do
+      it "returns the same role" do
+        expected = subject.role(:admin)
+        subject.role(:admin).should === expected
+      end
+    end
+
+    context "passing in a role that is not already defined" do
+      it "raises an error" do
+        subject.class_eval do
+          roles do
+            role(:admin)
+          end
+        end
+        lambda { subject.role(:user) }.should raise_error
+      end
+    end
+  end
+end

data/spec/reuser/instances_spec.rb

@@ -0,0 +1,34 @@
+require_relative '../spec_helper'
+
+describe "Instances of a Class including ReUser" do
+  let(:klass) do
+    kls = Class.new
+    kls.instance_eval do
+      include ReUser
+
+      roles do
+        role :admin do |admin|
+          admin.can :read
+          admin.could :write do |language|
+            language == "English"
+          end
+        end
+      end
+    end
+    kls
+  end
+
+  subject do
+    instance = klass.new
+    instance.instance_variable_set(:@role, klass.role(:admin))
+    instance
+  end
+
+  it "#can? and #could? are delegated to the ReUser::Role" do
+    true
+  end
+
+  it "#cant? and #couldnt? are negations of #can? and #could?" do
+    true
+  end
+end

data/spec/reuser/role_spec.rb

@@ -0,0 +1,49 @@
+require_relative '../spec_helper'
+
+describe ReUser::Role do
+  subject do
+    role = ReUser::Role.new(:admin)
+    role.can(:read)
+    role
+  end
+
+  it 'is initialized with a name, and optionally an array of permissions' do
+    role = ReUser::Role.new :admin
+    role.name.should == :admin
+    role.permissions.should == []
+
+    role = ReUser::Role.new :user
+    role.name.should == :user
+    role.permissions.should == []
+
+    role = ReUser::Role.new :user, [:read, :write]
+    role.name.should == :user
+    role.permissions.should == [:read, :write]
+  end
+
+  context 'shares its name and permissions' do
+    its(:name) { should === :admin }
+    its(:permissions) { should === [:read] }
+  end
+
+  it 'permissions are added and checked with #can and #can?' do
+    subject.can?(:read).should be_true
+    subject.can?(:write).should be_false
+    subject.can(:write)
+    subject.can?(:write).should be_true
+  end
+
+  it 'you need to supply #could with a test block' do
+    lambda { subject.could(:read) }.should raise_error
+  end
+
+  it 'conditional permissions are added and checked with #could and #could?' do
+    subject.can?(:write).should be_false
+    subject.could :write do |language|
+      language == "English"
+    end
+    subject.can?(:write).should be_true
+    subject.could?(:write, "Japanese").should be_false
+    subject.could?(:write, "English").should be_true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+$: << '../'
+$: << './'
+require 'lib/reuser'
+autoload :ReUser, 'lib/reuser'
+require 'rspec/expectations'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reuser
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,23 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-25 00:00:00.000000000 Z
+date: 2012-02-03 00:00:00.000000000 Z
 dependencies: []
 description: ReUse is an Internal DSL for Ruby to create roles and manage actions.
-email: isaacsanders@gmail.com
+email: isaac@isaacsanders.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/reuser.rb
 - lib/reuser/role.rb
-- lib/reuser/reuser.rb
-- Rakefile
-- README.md
-- spec/reuser.rb
-- spec/reuser/test_reuser.rb
-- spec/reuser/reuser_spec.rb
-homepage: http://isaacsanders.github.com/reuser
+- lib/reuser/version.rb
+- spec/spec_helper.rb
+- spec/reuser/class_spec.rb
+- spec/reuser/role_spec.rb
+- spec/reuser/instances_spec.rb
+homepage: http://isaacbfsanders.com/reuser
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -45,11 +44,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.6
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: An internal DSL for Ruby to make user role management simple.
 test_files:
-- spec/reuser.rb
-- spec/reuser/test_reuser.rb
-- spec/reuser/reuser_spec.rb
+- spec/spec_helper.rb
+- spec/reuser/class_spec.rb
+- spec/reuser/role_spec.rb
+- spec/reuser/instances_spec.rb

data/README.md

@@ -1,95 +0,0 @@
-#ReUser
-##Purpose
-  Whenever you start a web app where a user has specific permissions, do you
-  end up writing your own solution or using something that has brain-bending
-  abstractions? If so, ReUser is the solution for you.
-##Description
-  ReUser is an Internal DSL for Ruby to create roles and manage actions.
-##Usage
-  Installing ReUser is easy:
-  
-    gem install reuser
-
-  Now to incorporate it into a model:
-  
-    require 'reuser'
-
-    class User
-      include ReUser
-
-      roles do
-
-        # declare a role with the can method, taking a list of actions.
-        role(:admin).can :read, :write, :execute 
-
-        role :user do |usr| # pass a block, so you can
-          usr.can :read
-
-          # declare a role, then declare a conditional action with could.
-          # could takes a list of names, then assigns a test to them.
-          # You can then ask your model:
-          ##usr.could?(:write, 'un-owned-file')
-          ###=> false
-          # or
-          ##usr.could?(:write, 'owned-file')
-          ###=> true
-          # could? will pass the second argument as the block's argument'
-
-          usr.could :write do |file|
-            usr.owns? file
-          end
-        end
-
-        # Or you can declare a role with the name, followed by an array of names
-        role :writer, [:read, :write]
-
-        # Then, you can declare a default, accessible by storing :default as
-        # your model's role, it will point to original role.
-        default :user
-      end
-    end
-
-  You can restrict the instances from doing things based on role:
-  
-    def administrate
-      if @user.role? :admin
-        administer
-      end
-    end
-
-  Or based on their actions:
-  
-    def do_something_risky
-      if @user.can?(:do_this)
-        do_it
-      else
-        tell_them_to_get_out!
-      end
-    end
-
-    def do_something_with_obj
-      if @user.could?(:write, file)
-        write file
-      else
-        raise 'Not your file!'
-      end
-    end
-    
-##Issues?
-  Please don't hesitate to open up an issue. You can even contribute! Which
-  brings me to...
-##Contributing!
-  This is open source, so I want others to help too. For now I have no plans
-  on adding too much more to this project, as far as functionality is
-  concerned, but don't let that get in your way of opening a request or forking
-  the project and adding something. I just ask that:
-
-  - You are polite about it.
-  - You test it.
-  - You explain it, or it is easy to read.
-
-  Following these will let us get along and make better software, quicker, and
-  with less bugs.(hypothetically)
-
-  I am still working on the final syntax, but we are getting closer. If you
-  have any suggestions on syntax, open a feature require

data/Rakefile

@@ -1,24 +0,0 @@
-desc 'build the .gem file from gemspec'
-task :build do
-  sh 'gem build reuser.gemspec'
-end
-
-desc 'install the gem from .gem file'
-task :install do
-  sh 'gem install reuser-*.gem'
-end
-
-desc 'push the gem to rubygems.org'
-task :push do
-  sh 'gem push reuser-*.gem'
-end
-
-desc 'make (build and install the gem from gemspec)'
-task :make => [:build, :install]
-
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.rspec_opts = '--color'
-end
-
-task :default => :spec

data/lib/reuser/reuser.rb

@@ -1,46 +0,0 @@
-require_relative('../reuser')
-
-module ReUser
-  class NoRoleError < StandardError; end;
-  class NoDefaultRoleError < StandardError; end;
-  instance_eval do
-    def included(subclass)
-      subclass.instance_eval do
-        def roles(&block)
-          @@roles ||= {}
-          yield if block
-          @@roles.freeze
-          @@roles.keys
-        end
-
-        def role(name, actions_list = nil, &block)
-          @@roles[name] ||= ReUser::Role.new(name)
-          role_name = @@roles[name]
-          yield(role_name) if block
-          if actions_list
-            role_name.can(*actions_list)
-          end
-          role_name
-        end
-      end
-      subclass.class_eval do
-
-        def can?(action)
-          !!@role.can?(action)
-        end
-
-        def cant?(action)
-          !@role.can?(action)
-        end
-
-        def could?(action, obj)
-          !!@role.could?(action, obj)
-        end
-
-        def couldnt?(action, obj)
-          !@role.could?(action, obj)
-        end
-      end
-    end
-  end
-end

data/spec/reuser/reuser_spec.rb

@@ -1,65 +0,0 @@
-require_relative 'test_reuser'
-
-describe TestReUser do
-  context "has included the ReUser module" do
-    it "should be able to define roles with blocks" do
-      test_ru = TestReUser.new(:admin)
-      test_ru.can?(:read).should == true
-    end
-
-    it "should be able to define roles with arrays" do
-      test_ru = TestReUser.new(:admin)
-      test_ru.can?(:read).should == true
-    end
-
-    context "has defined the :admin and :user roles," do
-      context "is instantiated as test_ru" do
-        context "with role :user" do
-          before do
-            @test_ru = TestReUser.new(:user)
-          end
-          context " using the default role" do
-            it "should not be able to write" do
-              @test_ru.cant?(:write).should == true
-            end
-
-            it "should be able to read" do
-              @test_ru.can?(:read).should == true
-            end
-
-            it "should not be able to call methods restricted to `:admin` roles" do
-              class InsufficientPermissionsError < StandardError;end
-              TestReUser.class_eval do
-                def foo
-                  if @role == :admin
-                    :something
-                  else
-                    raise InsufficientPermissionsError, "You can't do that!"
-                  end
-                end
-              end
-
-              lambda {@test_ru.foo}.should raise_error(InsufficientPermissionsError)
-            end
-          end
-
-          it "should be able to execute on a 1 object." do
-            @test_ru.could?(:execute, 1).should == true
-            @test_ru.couldnt?(:execute, 3).should == true
-          end
-        end
-
-        context "set role to :admin" do
-          before do
-            @test_ru = TestReUser.new :admin
-          end
-          it "should be able to read, write, and execute" do
-            @test_ru.can?(:read).should == true
-            @test_ru.can?(:write).should == true
-            @test_ru.can?(:execute).should == true
-          end
-        end
-      end
-    end
-  end
-end

data/spec/reuser/test_reuser.rb

@@ -1,22 +0,0 @@
-require_relative '../reuser'
-
-class TestReUser
-  include ReUser
-
-  roles do
-    role(:admin).can(:read, :write, :execute)
-    role(:user) do |usr|
-      usr.can :read
-
-      usr.could :execute do |obj|
-        obj == 1
-      end
-    end
-    role :writer, :write
-    role :sysadmin, [:write, :execute]
-  end
-
-  def initialize(name)
-    @role = TestReUser.role(name)
-  end
-end

data/spec/reuser.rb

@@ -1 +0,0 @@
-require_relative '../lib/reuser'