simple_can 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5daf03f9ba885c925c8babfb731665322b46e6b0
+  data.tar.gz: 5c94acabaa8e22c4ef19f6c7c0d81fccdaf4ec80
+SHA512:
+  metadata.gz: 504b9ba0bcdf5d56de83e80b12499d027a967e161eda69af9c3c80aae3fcc7af57c56ff11418da233a78add825b99a192a867a028a9442c73d1e5ae409fad2f1
+  data.tar.gz: 8244f00ad7c0720279abe255612841db5730e02591d978ba3ef00ad63036367f43cebac22776212a97b9f8dd09aa0700e9b540636fae888baf9f19b37db93125

data/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2017, Matthias Geier
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/lib/simple_can/basic_strategy.rb

@@ -0,0 +1,26 @@
+module SimpleCan
+  module BasicStrategy
+    extend self
+
+    ROLES = %w(read write manage).freeze
+    REV_ROLES = ROLES.map.with_index.to_h.freeze
+
+    def test(role, capability)
+      capability = 0 if capability.nil?
+      capability >= to_capability(role)
+    end
+
+    def roles
+      ROLES
+    end
+
+    def fail(_role, _name)
+      :unauthorized
+    end
+
+    def to_capability(role)
+      return if role.nil?
+      REV_ROLES[role]
+    end
+  end
+end

data/lib/simple_can.rb

@@ -0,0 +1,88 @@
+require "simple_can/basic_strategy"
+
+module SimpleCan
+  THREAD_VAR = "simple_can.capability"
+
+  class << self; attr_accessor :strategy; end
+
+  class Unauthorized < StandardError; end
+
+  def self.included(mod)
+    meta = class << mod; self; end
+    meta.send(:alias_method, :orig_method_added, :method_added)
+    meta.send(:alias_method, :orig_singleton_method_added,
+      :singleton_method_added)
+    mod.extend(ClassMethods)
+
+    strategy.roles.each do |role|
+      [meta, mod].each do |scope|
+        scope.send(:define_method, "#{role}?") do
+          mod.strategy_set!
+          SimpleCan.strategy.test(role, mod.capability)
+        end
+        scope.send(:define_method, "#{role}!") do
+          mod.strategy_set!
+          next if SimpleCan.strategy.test(role, mod.capability)
+          raise SimpleCan::Unauthorized, "unauthorized with #{role}"
+        end
+      end
+    end
+  end
+
+  module ClassMethods
+    def strategy_set!
+      raise "strategy missing" if SimpleCan.strategy.nil?
+    end
+
+    def method_added(method)
+      orig_method_added(method)
+      add_method_to(self, method)
+    end
+
+    def singleton_method_added(method)
+      orig_singleton_method_added(method)
+      add_method_to((class << self; self; end), method)
+    end
+
+    def add_method_to(scope, method)
+      strategy_set!
+
+      klass = self
+      method = method.to_s
+      role, name, do_raise = SimpleCan.strategy.roles.reduce(nil) do |acc, r|
+        acc || method.match(/^#{r}_(.+(!)|.+)$/)&.captures&.unshift(r)
+      end
+      return if name.nil?
+      scope.send(:define_method, name) do |*args, &blk|
+        can = SimpleCan.strategy.test(role, klass.capability)
+        if !can && !do_raise.nil?
+          raise SimpleCan::Unauthorized, "unauthorized for #{name} with #{role}"
+        elsif !can
+          if respond_to?("fail_#{name}")
+            return send("fail_#{name}")
+          else
+            return SimpleCan.strategy.fail(role, name)
+          end
+        else
+          return send(method, *args, &blk)
+        end
+      end
+    end
+
+    def capability=(role)
+      strategy_set!
+      Thread.current[THREAD_VAR] = SimpleCan.strategy.to_capability(role)
+    end
+
+    def capability
+      Thread.current[THREAD_VAR]
+    end
+
+    def with_capability(role)
+      self.capability = role
+      yield
+    ensure
+      self.capability = nil
+    end
+  end
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: simple_can
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Matthias Geier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-17 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/simple_can.rb
+- lib/simple_can/basic_strategy.rb
+homepage: https://github.com/matthias-geier/simple_can
+licenses:
+- BSD-2-Clause
+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.5.1
+signing_key: 
+specification_version: 4
+summary: A thread-safe minimal authorization helper
+test_files: []