canned 0.1.4

data/Gemfile

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

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+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,39 @@
+# Canned
+
+Profile based authorization for ruby, with rails bindings.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'canned'
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install canned
+
+## Usage
+
+TODO: Write usage instructions here
+
+## TODO
+
+	* TODO Section
+	* database backed profiles (maybe thats another gem...)
+	* Attribute accessibility helpers
+
+## Credits
+
+Some ideas about resource managing and general gem structure where taken from [canned](http://github.com/ryanb/cancan).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,23 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Canned'
+  rdoc.options << '--line-numbers'
+  # rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks

data/lib/canned.rb

@@ -0,0 +1,9 @@
+require "canned/version"
+require "canned/controller_ext"
+
+# Extend action controller
+if defined? ActionController::Base
+  ActionController::Base.class_eval do
+    include Canned::ControllerExt
+  end
+end

data/lib/canned/context/actor.rb

@@ -0,0 +1,31 @@
+module Canned
+  module Context
+
+    class Actor < Base
+      include Matchers::Where
+      include Matchers::Has
+      include Matchers::Is
+      include Matchers::That
+      include Matchers::AsksFor
+      include Matchers::AsksWith
+      include Matchers::Load
+
+      def asks_with_same_id(*_args)
+        _args.all? { |a| asks_with_id(a).equal_to(own: a) }
+      end
+
+      def asks_with_same(*_args)
+        _args.all? { |a| asks_with(a).equal_to(own: a) }
+      end
+
+      def owns(_resource, _options={})
+        loads(_resource).that_belongs_to_it(_options)
+      end
+
+      def belongs_to(_resource, _options={})
+        loads(_resource).to_which_it_belongs(_options)
+      end
+
+    end
+  end
+end

data/lib/canned/context/base.rb

@@ -0,0 +1,40 @@
+Dir[File.dirname(__FILE__) + '/matchers/*.rb'].each { |file| require file }
+
+module Canned
+  module Context
+    ## Base class for other context types
+    class Base
+
+      def initialize(_ctx, _ext, _stack)
+        @ctx = _ctx
+        @ext = _ext
+        @stack = _stack
+      end
+
+      ## The method missing callback is used to hook extensions provided by context.
+      def method_missing(_method, *_args, &_block)
+        ext = @ext[_method]
+        return super if ext.nil?
+        instance_exec(*_args, &exc)
+      end
+
+      ## Returns true if context is in a "loaded" state
+      def indeed?
+        return @stack != false
+      end
+
+    private
+
+      def _chain_context(_klass, _proc)
+        # this is the preferred way of changing the context type
+        # should be called by matchers that wish to change the context.
+        stack = if @stack then yield @stack else false end
+
+        if _proc.nil? then _klass.new(@ctx, @ext, stack)
+        elsif stack then _klass.new(@ctx, @ext, stack).instance_eval &_proc
+        else false end
+      end
+
+    end
+  end
+end

data/lib/canned/context/default.rb

@@ -0,0 +1,10 @@
+module Canned
+  module Context
+    class Default < Base
+      include Matchers::The
+      include Matchers::Load
+      include Matchers::AsksWith
+      include Matchers::AsksFor
+    end
+  end
+end

data/lib/canned/context/matchers/asks_for.rb

@@ -0,0 +1,19 @@
+module Canned
+  module Context
+    module Matchers
+      module AsksFor
+
+        ## Tests the action name
+        #
+        # @param [String|Symbol] _actions actions that will return true
+        # @returns [Boolean] true if current action matches any one of **_actions**
+        #
+        def asked_for(*_actions)
+          _actions.any? { |a| a.to_s == @ctx.action_name }
+        end
+        alias :asks_for :asked_for
+
+      end
+    end
+  end
+end

data/lib/canned/context/matchers/asks_with.rb

@@ -0,0 +1,36 @@
+module Canned
+  module Context
+    module Matchers
+      module AsksWith
+
+        ## Loads a value context for a given parameter
+        #
+        # @param [String|Symbol] Parameter key
+        # @param [Hash] _options Various options:
+        #     * as: If given, the value will use this value as alias for **where** blocks instead of the key.
+        # @param [Block] _block If given, then the block will be evaluated in the value context and the result
+        # of that returned by this function.
+        #
+        def asked_with(_key, _options={}, &_block)
+          _chain_context(Canned::Context::Value, _block) do |stack|
+            param = @ctx.params[_key]
+            break false if param.nil?
+            stack.push :value, _options.fetch(:as, _key), param
+          end
+        end
+        alias :asks_with :asked_with
+
+        ## Same as **asked_with** but transforms parameter to an int.
+        def asked_with_id(_key, _options={}, &_block)
+          _chain_context(Canned::Context::Value, _block) do |stack|
+            param = @ctx.params[_key]
+            break false if param.nil?
+            stack.push :value, _options.fetch(:as, _key), param.to_i
+          end
+        end
+        alias :asks_with_id :asked_with_id
+
+      end
+    end
+  end
+end

data/lib/canned/context/matchers/equality.rb

@@ -0,0 +1,48 @@
+module Canned
+  module Context
+    module Matchers
+      module Equality
+
+        ## Returns true if a given value equals current context value.
+        #
+        # @param [Object] _value to compare to.
+        # @param [Hash] _options various options:
+        #     * own: if set, context value is compared to the closest containing actor context attribute **own**.
+        #
+        def equal_to(_options={})
+          return false unless indeed?
+          @stack.top == _equality_load_value(_options)
+        end
+
+        ## Works the same as **equal_to** but performs a **greater_than** comparison
+        def greater_than(_options={})
+          return false unless indeed?
+          @stack.top > _equality_load_value(_options)
+        end
+
+        ## Works the same as **equal_to** but performs a **less_than** comparison
+        def less_than(_options={})
+          return false unless indeed?
+          @stack.top < _equality_load_value(_options)
+        end
+
+      private
+
+        # @api auxiliary
+        def _equality_load_value(_options)
+          return _options unless _options.is_a? Hash
+
+          own = _options[:own]
+          if own
+            # use last actor as reference
+            actor = @stack.top(:actor)
+            raise Canned::SetupError.new '"own" option requires an enclosing actor context' if actor.nil?
+            return Helpers.resolve(actor, own)
+          end
+
+          return _options[:value]
+        end
+      end
+    end
+  end
+end

data/lib/canned/context/matchers/has.rb

@@ -0,0 +1,23 @@
+module Canned
+  module Context
+    module Matchers
+      module Has
+
+        ## Acts on one of the top resource's attributes
+        #
+        #    Examples:
+        #       upon { loaded(:raffle).has(:app_id) { equal_to(20) or less_than(20) } }
+        #       upon { loaded(:raffle).has('ceil(upper)').greater_than(20)
+        #
+        def has(_key, _options={}, &_block)
+          _chain_context(Canned::Context::Value, _block) do |stack|
+            value = Helpers.resolve(stack.top, _key)
+            stack.push(:value, _options.fetch(:as, _key), value)
+          end
+        end
+
+        alias :have :has
+      end
+    end
+  end
+end

data/lib/canned/context/matchers/helpers.rb

@@ -0,0 +1,13 @@
+module Canned
+  module Context
+    module Matchers
+      module Helpers
+
+        def self.resolve(_target, _key)
+          if _target.is_a? Hash then _target[_key] else _target.send(_key) end
+        end
+
+      end
+    end
+  end
+end

data/lib/canned/context/matchers/is.rb

@@ -0,0 +1,23 @@
+module Canned
+  module Context
+    module Matchers
+      module Is
+        ## Test an expression or property
+        #
+        #    Examples:
+        #       upon { a(:calculator).is(:is_open?) }
+        #       upon { the(:user).is('level > 20') }
+        #
+        # @param [String|Symbol] _key The value of _key is resolved in the current context object.
+        # @returns [Boolean] True if conditions are met
+        #
+        def is(_key)
+          return false unless indeed?
+          Helpers.resolve(@stack.top, _key)
+        end
+
+        alias :are :is
+      end
+    end
+  end
+end

data/lib/canned/context/matchers/load.rb

@@ -0,0 +1,26 @@
+module Canned
+  module Context
+    module Matchers
+      module Load
+
+        ## Loads a resource and returns a resource context.
+        #
+        # @param [String|Symbol] _name Resource name
+        # @param [Hash] _options Various options:
+        #     * as: If given, the resource will use **as** as alias for **where** blocks instead of the name.
+        # @param [Block] _block If given, then the block will be evaluated in the resource context and the result
+        # of that returned by this function.
+        #
+        def loaded(_name, _options={}, &_block)
+          _chain_context(Canned::Context::Resource, _block) do |stack|
+            res = @ctx.resources[_name]
+            next false if res.nil?
+            stack.push(:resource, _options.fetch(:as, _name), res)
+          end
+        end
+
+        alias :loads :loaded
+      end
+    end
+  end
+end

data/lib/canned/context/matchers/plus.rb

@@ -0,0 +1,19 @@
+module Canned
+  module Context
+    module Matchers
+      module Plus
+
+        ## Very similar to **Load.load**, but does not accepts a block and
+        # returns **multi** context that only allows to execute where operations
+        def plus(_name, _options={})
+          _chain_context(Canned::Context::Multi, nil) do |stack|
+            resource = @ctx.resources[_resource]
+            return false if resource.nil?
+            @stack.push(:resource, _options.fetch(:as, _name), resource)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/canned/context/matchers/relation.rb

@@ -0,0 +1,52 @@
+module Canned
+  module Context
+    module Matchers
+      module Relation
+
+        def to_which_it_belongs(_options={})
+          return false unless indeed?
+
+          actor = @stack.top(:actor)
+          raise Canned::SetupError.new '"to_which_it_belongs" require an enclosing actor context' if actor.nil?
+
+          resource = @stack.top
+
+          as = _options[:as]
+          as = resource.class.name.parameterize if as.nil?
+
+          if actor.respond_to? :reflect_on_association
+            assoc = actor.reflect_on_association(as)
+            raise Canned::SetupError.new 'Invalid association name' if assoc.nil?
+            raise Canned::SetupError.new 'Thorugh assoc is not supported' if assoc.options.has_key? :through # TODO: support through!
+            raise Canned::SetupError.new 'Invalid association type' if assoc.macro != :belongs_to
+            actor.send(assoc.foreign_key) == resource.id
+          else
+            Helpers.resolve(resource, :id) == Helpers.resolve(actor, "#{as}_id".to_sym)
+          end
+        end
+
+        def that_belongs_to_it(_options={})
+          return false unless indeed?
+
+          actor = @stack.top(:actor)
+          raise Canned::SetupError.new '"that_belongs_to_it" require an enclosing actor context' if actor.nil?
+          resource = @stack.top
+
+          as = _options[:as]
+          as = resource.class.name.parameterize if as.nil?
+
+          if resource.respond_to? :reflect_on_association
+            assoc = resource.reflect_on_association(as)
+            raise Canned::SetupError.new 'Invalid association name' if assoc.nil?
+            raise Canned::SetupError.new 'Thorugh assoc is not supported' if assoc.options.has_key? :through # TODO: support through!
+            raise Canned::SetupError.new 'Invalid association type' if assoc.macro != :belongs_to
+            resource.send(assoc.foreign_key) == actor.id
+          else
+            Helpers.resolve(actor, :id) == Helpers.resolve(resource, "#{as}_id".to_sym)
+          end
+        end
+
+      end
+    end
+  end
+end