can_i 0.1

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/
+*.gem
+.DS_Store
+/build/

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+gem "bubble-wrap"
+gem "motion-stump"

data/Gemfile.lock

@@ -0,0 +1,12 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    bubble-wrap (1.1.5)
+    motion-stump (0.2.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bubble-wrap
+  motion-stump

data/README.md

@@ -0,0 +1,80 @@
+# Can I?
+Provides a simple DSL to define actions as roles in your [RubyMotion](http://www.rubymotion.com) app.  Requires [BubbleWrap](https://github.com/rubymotion/BubbleWrap) as a dependency.
+
+## Installation
+
+Add the following to your project's `Rakefile` to work with bundler.
+
+```ruby
+gem "can_i"
+```
+
+Install with bundler:
+
+```ruby
+bundle install
+```
+
+## Using the Authorization class
+I recommend you create an instance and store it in your application delegate.
+
+```ruby
+  class AppDelegate
+    attr_accessor :authorization
+    def application(application, didFinishLaunchingWithOptions:launchOptions)
+      self.authorization = CanI::Authorization.new :admin
+      true
+    end
+  end
+```
+
+Now, wherever you want to request access:
+
+```ruby
+puts "can do that thing" if App.delegate.authorization.can? :perform_action
+```
+### Helper Methods
+You'll be doing that so much, that there are included shortcut methods.  This expects you to have an `CanI::Authorization` or subclass of, accessible at `App.delegate.authorization`.
+
+You'll need to first include a module, like so:
+
+```ruby
+class SomeView < UIview
+  include CanI::HelperMethods
+  def initWithFrame(f)
+    super
+    self << my_custom_button if can? :can_push_button
+    self
+  end
+end
+```
+
+## Custom Authorization Roles
+You can easily create custom authorization roles to easily define sets of roles.
+
+Let's create a base role that everyone will use in our app.
+
+```ruby
+class BaseRole < CanI::AuthorizationRole
+  authorization_roles do
+    can :view_help
+  end
+end
+```
+
+Now, let's let admin users do something different:
+
+```ruby
+class AdminRole < BaseRole
+  authorization_roles do
+    cannot :view_help
+    can :fire_people
+  end
+end
+```
+
+You associate a role with the authorization system when you create your authorization instance.  Pass a symbol, which will have "Role" tacked on before looking up the class at runtime.
+
+```ruby
+App.delegate.authorization = CanI::Authorization.new :admin
+```

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+
+$:.unshift('/Library/RubyMotion/lib')
+require 'motion/project'
+require 'bundler'
+
+Bundler.require
+
+Dir[File.expand_path('../lib/**/*', __FILE__)].each { |f| require f }
+
+Motion::Project::App.setup do |app|
+  # Use `rake config' to see complete project settings.
+  app.name = 'CanI'
+end

data/app/app_delegate.rb

@@ -0,0 +1,5 @@
+class AppDelegate
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    return true if RUBYMOTION_ENV == 'test'
+  end
+end

data/can_i.gemspec

@@ -0,0 +1,19 @@
+require File.expand_path('../lib/can_i/version.rb', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = 'can_i'
+  s.version       = CanI::Version
+  s.authors       = ["Matt Brewer"]
+  s.email         = 'matt.brewer@me.com'
+
+  s.summary       = "Provides an easy way to define roles for performing actions in your RubyMotion app."
+  s.description   = "Provides an easy way to define roles for performing actions in your RubyMotion app."
+
+  s.homepage      = "https://github.com/macfanatic/rubymotion_roles"
+  s.files         = `git ls-files`.split($\)
+  s.test_files    = s.files.grep(%r{^spec/})
+  s.require_paths = ['lib']
+
+  s.add_dependency "bubble-wrap"
+
+end

data/lib/can_i.rb

@@ -0,0 +1,9 @@
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  Dir.glob(File.join(File.dirname(__FILE__), 'can_i/**/*.rb')).each do |file|
+    app.files.unshift(file)
+  end
+end

data/lib/can_i/authorization.rb

@@ -0,0 +1,61 @@
+module CanI
+  class Authorization
+
+    #
+    # This is the main class to interact with to determine if
+    # an action is permitted, or to define permissions
+    #
+    # Usage:
+    #  
+    #   class AppDelegate
+    #     attr_accessor :authorization
+    #     def application(application, didFinishLaunchingWithOptions:launchOptions)
+    #       self.authorization = CanI::Authorization.new :admin
+    #       true
+    #     end
+    #   end
+    #
+    #   class MyController < UIViewController
+    #     def viewDidLoad
+    #       if App.delegate.authorization.can? :get_drunk
+    #         App.alert "Let's get drunk!"
+    #       else
+    #         App.alert "I'm married"
+    #       end
+    #     end
+    #   end
+    #
+
+    attr_reader :auth_role
+
+    def initialize(role=:authorization)
+
+      klass = CanI.const_defined?("#{role}_role".camelize) ? CanI.const_get("#{role}_role".camelize) : Kernel.const_get("#{role}_role".camelize)
+
+      @auth_role = klass.new
+      auth_role.class.registration_blocks.each do |more_roles|
+        instance_eval &more_roles
+      end
+    end
+
+    def can(action)
+      approved_actions << action.to_sym unless approved_actions.include?(action.to_sym)
+    end
+
+    def can?(action)
+      approved_actions.include? action.to_sym
+    end
+
+    def cannot(action)
+      approved_actions.delete action.to_sym
+    end
+
+
+    private
+
+    def approved_actions
+      @approved_actions ||= []
+    end
+
+  end
+end

data/lib/can_i/authorization_role.rb

@@ -0,0 +1,38 @@
+module CanI
+  class AuthorizationRole
+
+    #
+    # Create your own subclass to use with the Authorization class
+    # You can define and undefine roles with a class method, as shown below
+    #
+    # Usage:
+    #   class AdminRole < CanI::AuthorizationRole
+    #     authorization_roles do
+    #       can :fire_people
+    #       cannot :sleep_in_cubicle
+    #     end
+    #   end
+    #
+    #   @auth = CanI::Authorization.new :admin
+    #   @auth.can? :fire_people
+    #   => true
+    #
+
+    class << self
+
+      def authorization_roles(&block)
+        registration_blocks << block
+      end
+
+      def registration_blocks
+        @@registration_blocks ||= []
+      end
+
+    end
+
+    # use to define additional rules in your subclass
+    authorization_roles do
+    end
+
+  end
+end

data/lib/can_i/helper_method.rb

@@ -0,0 +1,18 @@
+module CanI
+  module HelperMethods
+
+    def can(action)
+      App.delegate.authorization.can action
+    end
+
+    def cannot(action)
+      App.delegate.authorization.cannot action
+    end
+
+    def can?(action) 
+      App.delegate.authorization.can? action
+    end
+
+  end
+
+end

data/lib/can_i/version.rb

@@ -0,0 +1,3 @@
+module CanI
+  Version = 0.1
+end

data/spec/authorization_roles_spec.rb

@@ -0,0 +1,35 @@
+describe "auth roles" do
+
+  before do
+    @auth = CanI::Authorization.new
+  end
+
+  it "should have a default role" do
+    @auth.auth_role.should.be.instance_of CanI::AuthorizationRole 
+  end
+
+  describe "custom auth roles" do
+
+    before do
+
+      class CustomRole < CanI::AuthorizationRole
+        authorization_roles do
+          can :my_role
+        end
+      end
+
+      @auth = CanI::Authorization.new :custom
+
+    end
+
+    it "should respect my custom auth role" do
+      @auth.auth_role.should.be.instance_of CustomRole
+    end
+
+    it "should allow custom roles to add definitions" do
+      @auth.can?(:my_role).should == true
+    end
+
+  end
+
+end

data/spec/helper_method_spec.rb

@@ -0,0 +1,13 @@
+describe "should provide helper methods to all objects" do
+
+  before do
+    @tester = HelperMethodsTestObject.new
+  end
+
+  it "should let me shortcut the DSL methods" do
+    @tester.should.respond_to :can
+    @tester.should.respond_to :cannot
+    @tester.should.respond_to :can?
+  end
+
+end

data/spec/helpers/helper_methods.rb

@@ -0,0 +1,3 @@
+class HelperMethodsTestObject
+  include CanI::HelperMethods
+end

data/spec/main_spec.rb

@@ -0,0 +1,32 @@
+describe "authorization functionality" do
+  
+  before do
+    @auth = CanI::Authorization.new
+  end
+
+  it "should not allow duplicates" do
+    before_adding_new_role = @auth.send(:approved_actions).count
+    @auth.can :some_action
+    @auth.can :some_action
+    @auth.send(:approved_actions).count.should.equal (before_adding_new_role+1)
+  end
+
+  it "should allow you to define access rules" do
+    @auth.can?(:my_action).should == false
+    @auth.can :my_action
+    @auth.can?(:my_action).should == true
+  end
+
+  it "should allow strings or symbols" do
+    @auth.can(:some_action)
+    @auth.can?('some_action').should == true
+    @auth.can('my_action')
+    @auth.can?(:my_action).should == true
+  end
+
+  it "should allow you to remove access" do
+    @auth.cannot :some_action
+    @auth.can?(:some_action).should == false
+  end
+
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: can_i
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Matt Brewer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bubble-wrap
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides an easy way to define roles for performing actions in your RubyMotion
+  app.
+email: matt.brewer@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- app/app_delegate.rb
+- can_i.gemspec
+- lib/can_i.rb
+- lib/can_i/authorization.rb
+- lib/can_i/authorization_role.rb
+- lib/can_i/helper_method.rb
+- lib/can_i/version.rb
+- spec/authorization_roles_spec.rb
+- spec/helper_method_spec.rb
+- spec/helpers/helper_methods.rb
+- spec/main_spec.rb
+homepage: https://github.com/macfanatic/rubymotion_roles
+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'
+      segments:
+      - 0
+      hash: 3259127327991234335
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Provides an easy way to define roles for performing actions in your RubyMotion
+  app.
+test_files:
+- spec/authorization_roles_spec.rb
+- spec/helper_method_spec.rb
+- spec/helpers/helper_methods.rb
+- spec/main_spec.rb