permissionable 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ac8b647c4c845648114c06ce701efeaf427a6c66
+  data.tar.gz: 435c2593102b61b7ec1c0ab917ae76584e1885cb
+SHA512:
+  metadata.gz: 4995603b3f0610a7dea21aa64d7a42041de7647f4afcfc885e7d78162454b24dce81d13e78e2cc0988b3ba506b3b12f76f719c715feef7f6be51b05553d65a96
+  data.tar.gz: 233663404592bc6c69ae5f9f9566f4b4dde70f6ae783c3b2e672e222be38906ff31e1d9286ba9767a21f544fc1c906c36484c7ff6989a8368fa148e3c0720b9e

data/.gitignore

@@ -0,0 +1,16 @@
+.bundle/
+.yardoc
+Gemfile.lock
+_yardoc/
+coverage/
+doc/
+pkg/
+spec/reports/
+tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.rspec
+permissionable*.gem

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Robert Falkén
+
+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,74 @@
+# permissionable
+## Installation
+TODO
+
+## Usage
+### Hooking up your model with permissionable super powers
+Hooking up your model is as easy as including `Permissionable` and defining your permission **schema**
+```
+include Permissionable
+permissions read: 1,
+            write: 2,
+            delete: 3
+```
+
+Your model doesn't have to be an ActiveRecord (AR) model, but Permissionable works out of the box with AR to persist the permissions. Just throw in a `permissions` column in the mix.
+```
+class AddPermissionsToResource < ActiveRecord::Migration
+  def change
+    add_column :resources, :permissions, :integer
+  end
+end
+```
+
+If your're not using AR can also implement your own `#read_attribute` and `#write_attribute` methods to handle `read_attribute(:permissions)` and `write_attribute(:permissions, permissions_integer)`
+
+### Working with permissions
+#### Check for permissions
+To check if your permissionable resource has a certain permission, use the [] method which will return true or false.
+
+For instance, to check if your user has permission to :read_books,   
+`user.permissions[:read_books]`
+
+You can also specify multiple permissions, which will check to see if your resource has all of the permissions provided (I.e. it will return false if any of the permissions are missing).  
+`user.permissions[:read_books, :delete_books]`
+
+**Note** if you find the permissions[:read_books, :delete_books] syntax awkward, you can also use #include?  
+`user.permissions.include?(:read_books, :delete_books)`
+
+#### Add permissions
+You can add permissions to your resource with the familiar "append to"-syntax. To add permissions to :read_books to your user:  
+`user.permissions << :read_books`
+
+You can also add an array of permissions yo your array of permissions:  
+`user.permissions << [:read_books, :delete_books]`
+
+**Note** Again, if special syntax like this isn't really your cup of tea, you can also use #add  
+`user.permissions.add(:read_books, :delete_books)`
+
+#### Remove permissions
+Removing permissions from your resource is pretty straight forward:  
+`user.permissions.remove(:delete_books)`
+
+### Examples
+```
+class User < ActiveRecord::Base
+  include Permissionable
+  
+  permissions read: 1,
+              write: 2,
+              delete: 3
+end
+```
+
+```
+user = User.create
+user.permissions[:read] # => false
+user.permissions << :read
+user.permissions[:read] # => true
+user.permissions[:read, :write] # => false
+user.permissions << :write
+user.permissions[:read, :write] # => true
+user.permissions.remove(:read)
+user.permissions[:read, :write] # => false
+```

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/permissionable.rb

@@ -0,0 +1,34 @@
+require "permissionable/version"
+require "permissionable/permissions"
+
+module Permissionable
+
+  def permissions
+    @permissions ||= Permissions.new(self)
+  end
+
+  # Class methods from here on
+  module ClassMethods
+    def permissions(permission_definitions)
+      @permissions = {}
+      permission_definitions.each do |permission,i|
+        raise 'Can not assign 0' if i == 0
+        raise "#{i} is not an integer" unless i.is_a?(Fixnum)
+        if i == 1
+          @permissions[permission] = 1 
+        else
+          @permissions[permission] = 2**(i-1)
+        end
+      end
+    end
+
+    def get_permissions
+      @permissions || {}
+    end
+  end
+
+  # Automatically extend class methods when module is included
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+end

data/lib/permissionable/permissions.rb

@@ -0,0 +1,81 @@
+module Permissionable
+  class Permissions
+    def initialize(owner)
+      @owner = owner
+      if @owner.respond_to?(:read_attribute)
+        @permission_integer = @owner.read_attribute(:permissions)
+      else
+        @permission_integer = 0
+      end
+    end
+
+    def to_i
+      @permission_integer
+    end
+
+    # Add new permissions
+    # will safely ignore any permissions already granted
+    # Usage:
+    # MyModel.last.permissions.add(:write)
+    # MyModel.last.permissions.add(:write, :read)
+    def add(*permissions)
+      permissions.flatten!
+      control_definitions(permissions)
+      permissions.each do |permission|
+        new_permission = defined_permissions[permission]
+        @permission_integer += new_permission unless include?(permission)
+      end
+      sync_with_owner
+    end
+    alias_method :<<, :add
+
+    # Remove existing permissions
+    # will safely ignore any permissions not already granted
+    # Usage:
+    # resource.permissions.remove(:write)
+    # resource.permissions.remove(:write, :read)
+    def remove(*permissions)
+      permissions.flatten!
+      control_definitions(permissions)
+      permissions.each do |permission|
+        @permission_integer -= defined_permissions[permission] if include?(permission)
+      end
+      sync_with_owner
+    end
+
+    # Check if resource has permission
+    # Usage:
+    # resource.permissions.include?(:write)
+    # resource.permissions.include?(:write, :read)
+    # @param *permissions [Array]
+    # @return [TrueClass, FalseClass]
+    def include?(*permissions)
+      permissions.flatten!
+      control_definitions(permissions)
+      # Sum the corresponding int value of all 
+      # permissions provided in the argument list
+      asserted = permissions.inject(0){ |mem, permission| mem + defined_permissions[permission] }
+      @permission_integer & asserted == asserted
+    end
+    alias_method :[], :include?
+
+    private 
+
+    def control_definitions(permissions)
+      permissions.each do |permission|
+        raise "Permission #{permission} not defined" if defined_permissions[permission].nil?
+      end
+    end
+
+    def sync_with_owner
+      if @owner.respond_to?(:write_attribute)
+        @owner.write_attribute(:permission, @permission_integer)
+      end
+    end
+
+    def defined_permissions
+      @owner.class.get_permissions
+    end
+
+  end
+end

data/lib/permissionable/version.rb

@@ -0,0 +1,3 @@
+module Permissionable
+  VERSION = "0.1.1"
+end

data/permissionable.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'permissionable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "permissionable"
+  spec.version       = Permissionable::VERSION
+  spec.authors       = ["Robert Falkén"]
+  spec.email         = ["f@lken.se"]
+  spec.summary       = "Manage and check permissions for your models"
+  spec.description   = "Integer backed permissions, powered by bitwise comparison"
+  spec.homepage      = "https://github.com/robertfalken/permissionable"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.3"
+end

data/spec/dummy.rb

@@ -0,0 +1,10 @@
+class Dummy
+  include Permissionable
+
+  permissions run: 1,
+              walk: 2,
+              sit: 3,
+              play: 4,
+              eat: 5
+
+end

data/spec/permissionable_spec.rb

@@ -0,0 +1,54 @@
+require 'pry'
+require 'permissionable'
+require 'dummy'
+
+
+class FlakyDummy
+  include Permissionable
+end
+
+describe Permissionable do
+  context 'permission definitions' do
+    subject(:permissions) { Dummy.instance_variable_get(:@permissions) }
+
+    context 'valid' do
+      it { is_expected.to have_key(:run) }
+      it { is_expected.to have_key(:walk) }
+      it { is_expected.to have_key(:sit) }
+      it { is_expected.to have_key(:play) }
+      it { is_expected.to have_key(:eat) }
+
+      it 'creates a geometric sequence' do
+        expect(permissions[:run]).to eq(1)
+        expect(permissions[:walk]).to eq(2)
+        expect(permissions[:sit]).to eq(4)
+        expect(permissions[:play]).to eq(8)
+        expect(permissions[:eat]).to eq(16)
+      end
+    end
+
+    context 'invalid' do
+      it 'can not assign 0' do
+        expect{
+          FlakyDummy.permissions(nope: 0)
+        }.to raise_exception
+      end
+
+      it 'can only assign integers' do
+        expect{
+          FlakyDummy.permissions(nope: '1')
+        }.to raise_exception
+      end
+    end
+  end
+
+  context 'instance' do
+    it 'has permissions getter' do
+      dummy = Dummy.new
+      expect(dummy).to respond_to(:permissions)
+      expect(dummy.permissions).to be_an_instance_of(Permissionable::Permissions)
+    end
+
+  end
+
+end

data/spec/permissions_spec.rb

@@ -0,0 +1,76 @@
+require 'pry'
+require 'permissionable'
+require 'dummy'
+
+describe Permissionable::Permissions do
+  before(:each) { @permissions = Permissionable::Permissions.new(Dummy.new) }
+
+  it 'implements #to_i' do
+    expect(@permissions.to_i).to eq(0)
+  end
+
+  it 'can add permission with <<' do
+    expect{
+      @permissions << :play
+    }.to change{@permissions.to_i}.by(8)
+  end
+
+  it 'can add permission with #add' do
+    expect{
+      @permissions << :walk
+    }.to change{@permissions.to_i}.by(2)
+  end
+
+  it 'can remove permission with #remove' do
+    @permissions << :play
+    expect{
+      @permissions.remove(:play)
+    }.to change{@permissions.to_i}.by(-8)
+  end
+
+  it 'is true with one included permission' do
+    @permissions << :run
+    expect(@permissions.include?(:run)).to be true
+  end
+
+  it 'is false with one missing permission' do
+    @permissions << :run
+    expect(@permissions.include?(:walk)).to be false
+  end
+
+  it 'is true for multiple existing permissions' do
+    @permissions << :run
+    @permissions << :walk
+
+    expect(@permissions.include?(:run, :walk)).to be true
+  end
+
+  it 'it is false when one of asserted is missing' do
+    @permissions << :run
+    @permissions << :walk
+    expect(@permissions.include?(:run, :play)).to be false
+  end
+
+  it 'can check with []' do
+    @permissions << :run
+    @permissions << :sit
+    expect(@permissions[:run]).to eq(true)
+    expect(@permissions[:sit, :run]).to eq(true)
+    expect(@permissions[:play]).to eq(false)
+  end
+
+  it 'writes attribute when adding permission' do
+    @owner = Dummy.new
+    @permissions = Permissionable::Permissions.new(@owner)
+    expect(@owner).to receive(:write_attribute).with(:permission, 2)
+    @permissions << :walk
+  end
+
+  it 'writes attribute when removing permission' do
+    @owner = Dummy.new
+    @permissions = Permissionable::Permissions.new(@owner)
+    @permissions << :run
+    expect(@owner).to receive(:write_attribute).with(:permission, 0)
+    @permissions.remove :run
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: permissionable
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Robert Falkén
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: Integer backed permissions, powered by bitwise comparison
+email:
+- f@lken.se
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/permissionable.rb
+- lib/permissionable/permissions.rb
+- lib/permissionable/version.rb
+- permissionable.gemspec
+- spec/dummy.rb
+- spec/permissionable_spec.rb
+- spec/permissions_spec.rb
+homepage: https://github.com/robertfalken/permissionable
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Manage and check permissions for your models
+test_files:
+- spec/dummy.rb
+- spec/permissionable_spec.rb
+- spec/permissions_spec.rb
+has_rdoc: