permify 0.0.1 → 1.5.4

data/lib/permify/clearance.rb

@@ -1,29 +0,0 @@
-# Clearance: Official authorization for something to proceed or take place
-#
-class Permify::Clearance
-  def initialize(repo)
-    @repo = repo
-    @permissions = Permify::PermissionMap.new
-  end
-
-  def add(resource, action)
-    permission = resolve_to_permission(resource, action)
-    permissions.store(resource, action, permission)
-  end
-
-  def find(resource, action)
-    if !repo.permission_combination?(resource, action)
-      permissions.find(resource, action) || Permify::Permission::Null.new
-    else
-      combination = repo.find_permission_combination(resource, action)
-      combination.resolve(self)
-    end
-  end
-
-  private
-  attr_reader :permissions, :repo
-
-  def resolve_to_permission(resource, action_name)
-    repo.find_permission(resource, action_name)
-  end
-end

data/lib/permify/permission/combination/any.rb

@@ -1,13 +0,0 @@
-class Permify::Permission::Combination
-  class Any < self
-    def initialize(permissions)
-      @permissions = permissions
-    end
-
-    def granted?(candidate, resource)
-      @permissions.any? { |perm|
-        perm.granted?(candidate, resource)
-      }
-    end
-  end
-end

data/lib/permify/permission/combination.rb

@@ -1,4 +0,0 @@
-class Permify::Permission
-  class Combination < self
-  end
-end

data/lib/permify/permission/combination_map.rb

@@ -1,23 +0,0 @@
-class Permify::Permission::CombinationMap
-  def initialize(combinations)
-    @combinations = combinations
-  end
-
-  def resolve(clearance)
-    permissions = list_permissions(clearance)
-    Permify::Permission::Combination::Any.new(permissions)
-  end
-
-  private
-  attr_reader :combinations
-
-  def list_permissions(clearance)
-    permissions = []
-    combinations.each do |resource, actions|
-      [actions].flatten.each do |action|
-        permissions << clearance.find(resource, action)
-      end
-    end
-    permissions
-  end
-end

data/lib/permify/permission/dynamic.rb

@@ -1,13 +0,0 @@
-class Permify::Permission
-  class Dynamic < self
-    def initialize(checks)
-      @checks = checks
-    end
-
-    def granted?(candidate, resource)
-      @checks.all? { |check|
-        check.new(candidate, resource).success?
-      }
-    end
-  end
-end

data/lib/permify/permission/null.rb

@@ -1,7 +0,0 @@
-class Permify::Permission
-  class Null < self
-    def granted?(candidate, resource)
-      false
-    end
-  end
-end

data/lib/permify/permission/static.rb

@@ -1,7 +0,0 @@
-class Permify::Permission
-  class Static < self
-    def granted?(candidate, resource)
-      true
-    end
-  end
-end

data/lib/permify/permission.rb

@@ -1,10 +0,0 @@
-module Permify
-  class Permission
-    def initialize(*args)
-    end
-
-    def granted?(candidate, context)
-      false
-    end
-  end
-end

data/lib/permify/permission_map.rb

@@ -1,32 +0,0 @@
-# Provides a convenient way to store and retrieve permission data
-class Permify::PermissionMap
-  def initialize
-    @data = {}
-  end
-
-  def store(resource, action, info)
-    resource_key, action_key = to_keys(resource, action)
-    data[resource_key] ||= {}
-    data[resource_key][action_key] = info
-  end
-
-  def find(resource, action)
-    resource_key, action_key = to_keys(resource, action)
-    data.fetch(resource_key, {})[action_key]
-  end
-
-  private
-  attr_reader :data
-
-  # Transforms resource and action into keys for use in internal hashes
-  #
-  # @param resource [Class, Object] resource object or its class
-  # @param action [String, #to_sym]
-  #
-  # @return keys [Array<Symbol>] array with resource and action key
-  #
-  def to_keys(resource, action)
-    resource_class = resource.is_a?(Class) ? resource : resource.class
-    [resource_class.name, action].map(&:to_sym)
-  end
-end

data/lib/permify/repository.rb

@@ -1,68 +0,0 @@
-class Permify::Repository
-
-  # Define a static permission
-  #
-  # @param resource_class [Class]
-  # @param action [Symbol, String]
-  #
-  # @return [undefined]
-  #
-  def static(resource_class, action)
-    permission = Permify::Permission::Static.new
-    permissions.store(resource_class, action, permission)
-  end
-
-  # Define a dynamic permission
-  #
-  # @param resource_class [Class]
-  # @param action [Symbol, String]
-  #
-  # @return [undefined]
-  #
-  def dynamic(resource_class, action, *args)
-    permission = Permify::Permission::Dynamic.new args.flatten
-    permissions.store(resource_class, action, permission)
-  end
-
-  # Creates a permission that's granted whenever any of the combined
-  # permissions is granted
-  #
-  # @param resource_class [Class]
-  # @param action [String, #to_sym]
-  #
-  # @return [undefined]
-  #
-  def any(resource_class, action, combinations)
-    combination_map = Permify::Permission::CombinationMap.new(combinations)
-    permission_combinations.store(resource_class, action, combination_map)
-  end
-
-  # Finds permission in this repository
-  #
-  # @param resource [Class]
-  # @param action [String, #to_sym]
-  #
-  # @return permission [Permify::Permission, nil]
-  #
-  def find_permission(resource, action)
-    permissions.find(resource, action)
-  end
-
-  def permission_combination?(resource_class, action)
-    !!find_permission_combination(resource_class, action)
-  end
-
-  def find_permission_combination(resource, action)
-    permission_combinations.find(resource, action)
-  end
-
-  protected
-
-  def permissions
-    @permissions ||= Permify::PermissionMap.new
-  end
-
-  def permission_combinations
-    @permission_combinations ||= Permify::PermissionMap.new
-  end
-end

data/spec/integration_spec.rb

@@ -1,114 +0,0 @@
-require "spec_helper"
-
-class Post
-  def initialize(owner)
-    @owner = owner
-  end
-
-  def owner?(user)
-    @owner == user
-  end
-end
-
-class OwnerCheck
-  attr_reader :candidate, :resource
-
-  def initialize(candidate, resource)
-    @candidate = candidate
-    @resource = resource
-  end
-
-  def success?
-    resource.owner?(candidate)
-  end
-end
-
-REPO = Permify::Repository.new
-
-REPO.static(Post, :show)
-REPO.static(Post, :create)
-
-# :edit permission granted if either of its dependencies (:edit_all or
-# :edit_own) is granted
-REPO.any(Post, :edit, { Post => [:edit_all, :edit_own] })
-
-REPO.static(Post, :edit_all)
-REPO.dynamic(Post, :edit_own, [OwnerCheck])
-
-class Admin
-  def permissions
-    Permify::Clearance.new(REPO).tap do |c|
-      c.add Post, :show
-      c.add Post, :create
-      c.add Post, :edit_all
-    end
-  end
-end
-
-class User
-  def permissions
-    Permify::Clearance.new(REPO).tap do |c|
-      c.add Post, :show
-      c.add Post, :create
-      c.add Post, :edit_own
-    end
-  end
-end
-
-describe Permify::Authorization, "integration" do
-  let(:post) { Post.new(post_owner) }
-  let(:post_owner) { user }
-  let(:admin) { Admin.new }
-  let(:user) { User.new }
-
-  describe "admin" do
-    let(:auth) { Permify::Authorization.new(admin) }
-
-    describe "static create" do
-      subject { auth.can?(:create, post)}
-      it { should be_true }
-    end
-
-    describe "static show" do
-      subject { auth.can?(:show, post)}
-      it { should be_true }
-    end
-
-    describe "static edit" do
-      subject { auth.can?(:edit, post)}
-      it { should be_true }
-    end
-  end
-
-  describe "user" do
-    let(:auth) { Permify::Authorization.new(user) }
-
-    describe "Post :edit_own" do
-      subject { auth.can?(:edit_own, post)}
-
-      context "when owner" do
-        let(:post_owner) { user }
-        it { should be_true }
-      end
-
-      context "when not owner" do
-        let(:post_owner) { admin }
-        it { should_not be_true }
-      end
-    end
-
-    describe "Post :edit" do
-      subject { auth.can?(:edit, post)}
-
-      context "when owner" do
-        let(:post_owner) { user }
-        it { should be_true }
-      end
-
-      context "when not owner" do
-        let(:post_owner) { admin }
-        it { should_not be_true }
-      end
-    end
-  end
-end