reuser 3.1.0 → 3.1.1

data/.gitignore

@@ -0,0 +1,5 @@
+coverage
+*.gem
+.rvmrc
+example
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - ree
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - ruby-head
+  - jruby-18mode
+  - jruby-19mode
+  - jruby-head
+  - rbx-18mode
+  - rbx-19mode
+  - rbx-head

data/Gemfile

@@ -0,0 +1,11 @@
+source :rubygems
+
+gem 'rake'
+
+group :test, :development do
+  gem "cucumber"
+  gem "rspec"
+  gem 'simplecov'
+end
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Isaac Sanders
+
+MIT License
+
+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/README.md

@@ -0,0 +1,109 @@
+#ReUser [![Build Status](https://secure.travis-ci.org/isaacsanders/reuser.png?branch=master)](http://travis-ci.org/isaacsanders/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:
+
+```ruby
+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:
+
+```ruby
+def administrate
+  if @user.role? :admin
+    administer
+  end
+end
+```
+
+Or based on their actions:
+
+```ruby
+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

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+
+task :spec do
+  sh 'rspec --color --format=nested'
+end
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = '--color'
+end
+
+task :default => [:spec, :features]

data/features/checking_permissions.feature

@@ -0,0 +1,145 @@
+Feature: Checking Permissions
+  In order to restrict my application
+  As a developer
+  I want to check permissions of my users
+
+  Scenario: Checking permissions on an empty role
+    Given the following class:
+    """
+    class User
+      include ReUser
+      attr_reader :role
+
+      roles do
+        role :admin
+      end
+
+      def initialize role
+        @role = role
+      end
+    end
+    """
+    When I create an "admin" user
+      And I ask if the user can read
+    Then I learn that they can't
+
+  Scenario: Checking permissions on a role with those permissions
+    Given the following class:
+    """
+    class User
+      include ReUser
+      attr_reader :role
+
+      roles do
+        role :admin do
+          can :read
+        end
+      end
+
+      def initialize role
+        @role = role
+      end
+    end
+    """
+    When I create an "admin" user
+      And I ask if the user can read
+    Then I learn that they can
+
+  Scenario: Checking conditional permissions
+    Given the following class:
+    """
+    class User
+      include ReUser
+      attr_reader :role
+
+      roles do
+        role :admin do
+          could :write do |language|
+            language == "English"
+          end
+        end
+      end
+
+      def initialize role
+        @role = role
+      end
+    end
+    """
+    When I create an "admin" user
+      And I ask if the user could write "English"
+    Then I learn that they can
+
+  Scenario: Checking conditional permissions
+    Given the following class:
+    """
+    class User
+      include ReUser
+      attr_reader :role
+
+      roles do
+        role :admin do
+          could :write do |language|
+            language == "English"
+          end
+        end
+      end
+
+      def initialize role
+        @role = role
+      end
+    end
+    """
+    When I create an "admin" user
+    And I ask if the user could write "Japanese"
+    Then I learn that they can't
+
+  Scenario: Checking permissions with a predicate
+    Given the following class:
+    """
+    class User
+      include ReUser
+      attr_reader :role
+
+      roles do
+        role :child do
+          could :read, &:old_enough?
+        end
+      end
+
+      def initialize role
+        @role = role
+        @age = 6
+      end
+
+      def old_enough?
+        @age > 5
+      end
+    end
+    """
+    When I create a "child" user
+    And I ask if the user can read
+    Then I learn that they can
+
+  Scenario: Checking permissions without state
+    Given the following class:
+    """
+    class User
+      include ReUser
+      attr_reader :role
+
+      roles do
+        role :child do
+          could :read do
+            true
+          end
+        end
+      end
+
+      def initialize role
+        @role = role
+      end
+    end
+    """
+    When I create a "child" user
+    And I ask if the user can read
+    Then I learn that they can

data/features/declaring_roles.feature

@@ -0,0 +1,63 @@
+Feature: Declaring Roles
+  In order to have simple role-based permissions
+  As a developer
+  I want to declare roles in my source code
+
+  Scenario: Declaring one role
+    Given the following class:
+    """
+    class User
+      include ReUser
+
+      roles do
+        role :admin
+      end
+    end
+    """
+    When I access "User.roles"
+    Then I should have an array of 1 role
+
+  Scenario: Declaring many roles
+    Given the following class:
+    """
+    class User
+      include ReUser
+
+      roles do
+        role :admin
+        role :user
+        role :butcher
+        role :baker
+        role :candlestick_maker
+      end
+    end
+    """
+    When I access "User.roles"
+    Then I should have an array of 5 roles
+
+  Scenario: Declaring roles outside of a block raises an error
+    Given the following class:
+    """
+    class User
+      include ReUser
+
+      roles do
+        role :admin
+      end
+    end
+    """
+    When I access "User.role(:user)"
+    Then I should get an error
+
+  Scenario: Declaring roles with an array of permissions
+    Given the following class:
+    """
+    class User
+      include ReUser
+
+      roles do
+        role :admin, [:read, :write, :execute]
+      end
+    end
+    """
+    Then I should know that an admin can read, write, and execute

data/features/step_definitions/declaring_roles_steps.rb

@@ -0,0 +1,33 @@
+Given /^the following class:$/ do |class_code|
+  eval class_code, binding, "feature_user_class"
+end
+
+When /^I access "([^"]*)"$/ do |access_code|
+  begin
+    @actual = eval access_code
+  rescue Exception => e
+    @actual = e
+  end
+end
+
+Then /^I should get an error$/ do
+  @actual.should be_kind_of Exception
+end
+
+Then /^I should know that an admin can read, write, and execute$/ do
+  [:read, :write, :execute].each do |permission|
+    User.role(:admin).should be_able_to permission
+  end
+end
+
+Then /^I should have an array of (\d+ roles?)$/ do |role_count|
+  @actual.should have(role_count).items
+  @actual.all? do |item|
+    item.should be_instance_of Symbol
+  end
+end
+
+Transform /(\d+) roles?/ do |role_count|
+  Integer(role_count)
+end
+

data/features/step_definitions/differentiation_steps.rb

@@ -0,0 +1,7 @@
+Then /^I should have know my role's name is "([^"]*)"$/ do |expected|
+  @actual.should == expected.to_sym
+end
+
+Then /^I should know that admins can read and write$/ do
+  @actual.should =~ [:read, :write]
+end

data/features/step_definitions/permission_steps.rb

@@ -0,0 +1,19 @@
+When /^I ask if the user could write "([^"]*)"$/ do |language|
+  @expected = @user.could? :write, language
+end
+
+When /^I create an? "([^"]*)" user$/ do |role_name|
+  @user = User.new(role_name.to_sym)
+end
+
+When /^I ask if the user can read$/ do
+  @expected = !!(@user.could? :read)
+end
+
+Then /^I learn that they can't$/ do
+  @expected.should be_false
+end
+
+Then /^I learn that they can$/ do
+  @expected.should be_true
+end

data/features/support/env.rb

@@ -0,0 +1,15 @@
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter '/spec/'
+    add_filter '/features/'
+  end
+end
+$: << 'lib'
+require 'reuser'
+
+After do
+  User.instance_eval do
+    class_variable_set(:@@roles, nil)
+  end
+end

data/features/support/predicates.rb

@@ -0,0 +1,7 @@
+module Roles
+  def role?
+    kind_of? ReUser::Role
+  end
+end
+
+World(Roles)

data/lib/reuser/role.rb

@@ -1,13 +1,6 @@
 module ReUser
   class Role
-    attr_reader :name
-
-    def permissions
-      @permissions.keys
-    end
-
-    def initialize name, permissions=[]
-      @name = name
+    def initialize *permissions
       @permissions = {}
       self.can *permissions
     end
@@ -19,7 +12,7 @@ module ReUser
     end
 
     def can? permission
-      @permissions[permission].is_a? Proc
+      @permissions.has_key?(permission) && @permissions[permission].is_a?(Proc)
     end
 
     def could permission, &block
@@ -27,8 +20,13 @@ module ReUser
       @permissions[permission] = block
     end
 
-    def could? permission, block_args
-      @permissions[permission].call(block_args)
+    def could? permission, *block_args
+      if @permissions.has_key?(permission)
+        @permissions[permission].call(*block_args)
+      else
+        false
+      end
     end
+    alias_method :able_to?, :could?
   end
 end

data/lib/reuser/role_definition.rb

@@ -1,3 +1,5 @@
+require 'reuser/role'
+
 module ReUser
   class RoleDefinition
     def initialize(definition)
@@ -10,8 +12,8 @@ module ReUser
     end
 
     def role name, permissions=[], &block
-      role = ReUser::Role.new(name, permissions)
-      yield(role) if block_given?
+      role = ReUser::Role.new(*permissions)
+      role.instance_eval &block if block_given?
       @roles[name] = role
     end
   end

data/lib/reuser/version.rb

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

data/lib/reuser.rb

@@ -1,4 +1,3 @@
-require 'reuser/role'
 require 'reuser/role_definition'
 require 'reuser/errors'
 
@@ -32,11 +31,14 @@ module ReUser
     !can?(permission)
   end
 
-  def could? permission, block_args
-    self.class.role(self.role).could? permission, block_args
+  def could? permission, *block_args
+    if block_args.empty?
+      block_args << self
+    end
+    self.class.role(self.role).could? permission, *block_args
   end
 
-  def couldnt? permission, block_args
-    !could?(permission, block_args)
+  def couldnt? permission, *block_args
+    !could?(permission, *block_args)
   end
 end

data/reuser.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'reuser/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "reuser"
+  gem.version       = ReUser::VERSION
+  gem.authors       = ["Isaac Sanders"]
+  gem.email         = ["isaac@isaacbfsanders.com"]
+  gem.description   = %q{ReUser is a DSL for Ruby to create roles and manage actions.}
+  gem.summary       = %q{An internal DSL for Ruby to make user role management simple.}
+  gem.homepage      = "http://isaacbfsanders.com/reuser"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/spec/reuser/role_definition_spec.rb

@@ -11,7 +11,6 @@ describe ReUser::RoleDefinition do
 
   describe '#role' do
     it "takes a symbol, and an optional array" do
-      puts subject
       lambda { subject.role(:admin, [:read, :write]) }.should_not raise_error
     end
   end

data/spec/reuser/role_spec.rb

@@ -2,35 +2,22 @@ require 'spec_helper'
 
 describe ReUser::Role do
   subject do
-    role = ReUser::Role.new(:admin)
+    role = ReUser::Role.new
     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] }
+  it 'is initialized with an optional array of permissions' do
+    role = ReUser::Role.new :read, :write
+    role.should be_able_to :read
+    role.should be_able_to :write
   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.should be_able_to :read
+    subject.should_not be_able_to :write
     subject.can(:write)
-    subject.can?(:write).should be_true
+    subject.should be_able_to :write
   end
 
   it 'you need to supply #could with a test block' do

data/spec/spec_helper.rb

@@ -1 +1,8 @@
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter '/spec/'
+    add_filter '/features/'
+  end
+end
 require 'reuser'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reuser
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,19 +9,34 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-14 00:00:00.000000000 Z
+date: 2012-08-15 00:00:00.000000000 Z
 dependencies: []
-description: ReUse is an Internal DSL for Ruby to create roles and manage actions.
-email: isaac@isaacsanders.com
+description: ReUser is a DSL for Ruby to create roles and manage actions.
+email:
+- isaac@isaacbfsanders.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- features/checking_permissions.feature
+- features/declaring_roles.feature
+- features/step_definitions/declaring_roles_steps.rb
+- features/step_definitions/differentiation_steps.rb
+- features/step_definitions/permission_steps.rb
+- features/support/env.rb
+- features/support/predicates.rb
+- lib/reuser.rb
 - lib/reuser/errors.rb
 - lib/reuser/role.rb
 - lib/reuser/role_definition.rb
 - lib/reuser/version.rb
-- lib/reuser.rb
+- reuser.gemspec
 - spec/reuser/class_spec.rb
 - spec/reuser/instances_spec.rb
 - spec/reuser/role_definition_spec.rb
@@ -41,13 +56,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -285099739461963091
+      hash: -1602940265211324019
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1602940265211324019
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -55,6 +73,13 @@ signing_key:
 specification_version: 3
 summary: An internal DSL for Ruby to make user role management simple.
 test_files:
+- features/checking_permissions.feature
+- features/declaring_roles.feature
+- features/step_definitions/declaring_roles_steps.rb
+- features/step_definitions/differentiation_steps.rb
+- features/step_definitions/permission_steps.rb
+- features/support/env.rb
+- features/support/predicates.rb
 - spec/reuser/class_spec.rb
 - spec/reuser/instances_spec.rb
 - spec/reuser/role_definition_spec.rb