reuser 0.2.0

data/README.md

@@ -0,0 +1,75 @@
+#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
+        role(:admin).can :read, :write, :execute
+        role :user do |usr|
+          usr.can :read
+          usr.could :write {|obj| usr.owns?(obj)}
+          usr.cant :execute
+        end
+        role :writer, [:read, :write]
+        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

@@ -0,0 +1,24 @@
+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]
+
+desc 'run all the specs in the `spec/` directory.'
+task :spec do
+  Dir.glob('./spec/reuser/**/*.rb').each do |file|
+    sh "rspec #{file}"
+  end
+end

data/lib/reuser/reuser.rb

@@ -0,0 +1,70 @@
+require_relative('../reuser')
+
+module ReUser
+  class NoRoleError < StandardError; end;
+  class NoDefaultRoleError < StandardError; end;
+  instance_eval do
+    def included(subclass)
+      subclass.instance_eval do
+        @@roles = {}
+        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
+
+        def default(name = nil)
+          if name
+            @@roles[:default] = @@roles[name]
+          else
+            @@roles[:default]
+          end
+        end
+      end
+      subclass.class_eval do
+
+        def role(name = nil)
+          if name
+            if @@roles[name]
+              @role = @@roles[name]
+            else
+              raise NoRoleError, "No role #{name} defined for #{self}"
+            end
+          end
+          @role
+        end
+
+        def role?(name)
+          role == self.class.role(name)
+        end
+
+        def can?(name)
+          !!role.can?(name)
+        end
+
+        def cant?(name)
+          !role.can?(name)
+        end
+
+        def could?(name, obj)
+          role.could?(name, obj)
+        end
+
+        def couldnt?(name, obj)
+          !role.could?(name, obj)
+        end
+      end
+    end
+  end
+end

data/lib/reuser/role.rb

@@ -0,0 +1,43 @@
+require_relative('../reuser')
+
+module ReUser
+  class Role
+    attr_reader :actions
+
+    def initialize(name)
+      @actions = {}
+    end
+
+    def can(*names)
+      names.each do |name|
+        action(name)
+      end
+    end
+
+    def can?(name)
+      actions[name]
+    end
+
+    def could(*names, &test)
+      names.each do |name|
+        action(name, test)
+      end
+    end
+
+    def could?(name, data)
+      @actions[name].call(data)
+    end
+
+    private
+      def actions(*names)
+        names.each do |name|
+          action(name)
+        end
+        @actions
+      end
+
+      def action(name, test = true)
+        @actions[name] = test
+      end
+  end
+end

data/lib/reuser.rb

@@ -0,0 +1,2 @@
+require_relative(reuser_file = './reuser/reuser')
+require_relative(role_file = './reuser/role')

data/spec/reuser/reuser.rb

@@ -0,0 +1,97 @@
+require 'rspec'
+require 'pry'
+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, :read do |obj|
+        obj == 1
+      end
+    end
+    role :writer, :write
+    role :sysadmin, [:write, :execute]
+    default(:user)
+  end
+
+  def initialize(name = :default)
+    @role = role(name)
+  end
+end
+REUSER_METHODS = [:roles,
+                  :role,
+                  :role?,
+                  :default,
+                  :can?,
+                  :cant?,
+                  :could?,
+                  :couldnt?].sort
+
+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 "set :user to the default" do
+          before do
+            @test_ru = TestReUser.new
+          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.rb

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

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: reuser
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Isaac Sanders
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-12 00:00:00.000000000Z
+dependencies: []
+description: ReUse is an Internal DSL for Ruby to create roles and manage actions.
+email: isaacsanders@gmail.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/reuser.rb
+homepage: http://isaacsanders.github.com/reuser
+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: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: An internal DSL for Ruby to make user role management simple.
+test_files:
+- spec/reuser.rb
+- spec/reuser/reuser.rb