cantango-core 0.1.3 → 0.1.4

data/README.mdown

@@ -27,9 +27,9 @@ Run bundler in a terminal/console from the folder of your Gemfile (root folder o
 
 `$ bundle`
 
-## CanTango components
+## CanTango core extensions
 
-CanTango has now been split up into these logical components:
+The following CanTango components extend core:
 
 * [Cantango core](https://github.com/kristianmandrup/cantango-core)
 * [Cantango config](https://github.com/kristianmandrup/cantango-config)
@@ -38,42 +38,20 @@ CanTango has now been split up into these logical components:
 * [Cantango masquerade](https://github.com/kristianmandrup/cantango-masquerade)
 * [Cantango roles](https://github.com/kristianmandrup/cantango-roles)
 
-Engines (Ability executors):
 
-* [Permits](https://github.com/kristianmandrup/cantango-permits)
-* [Permit store](https://github.com/kristianmandrup/cantango-permit_store)
-* [Permissions](https://github.com/kristianmandrup/cantango-permissions)
+## Extending core
 
-Cantango:
+To extend core, you should follow the CanTango extension conventions. We will demonstrate these conventions using the _-api_ extension as an example. The extension file structure should look like this:
 
-* [Cantango](https://github.com/kristianmandrup/cantango)
+```text
+/cantango
+  /api
+  /api_ext
+  api.rb
+  api_ext.rb_
+```
 
-Currently the _cantango-1x_ branch
-
-## Quickstart
-
-See the [Quickstart guide](https://github.com/kristianmandrup/cantango/wiki/Quickstart) in the wiki.
-
-For [devise](https://github.com/plataformatec/devise) integration, see [Quickstart CanTango with Devise](https://github.com/kristianmandrup/cantango/wiki/Quickstart-cantango-with-devise)
-
-The following scenarios demonstrate some of the problems CanTango can help solve in an elegant way
-
-* [Simple scenario](https://github.com/kristianmandrup/cantango/wiki/Simple-scenario)
-* [Complex scenario](https://github.com/kristianmandrup/cantango/wiki/Complex-scenario)
-
-### Generators
-
-Cantango comes with a set of [Generators](https://github.com/kristianmandrup/cantango/wiki/Generators) to get your app dancing...
-
-Install CanTango using
-
-* cantango:install
-
-`$ rails g cantango:install`
-
-### Configuration
-
-The CanTango [Configuration](https://github.com/kristianmandrup/cantango/wiki/Configuration) consists of a nice nested configuration DSL.
+The main API logic should go in the `cantango/api` folder. Extensions to core go into the `cantango/api_ext` folder. The extensions should use the same folder structure as core if possible.
 
 ## Contributing to cantango-core
  

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/cantango-core.gemspec

@@ -4,14 +4,17 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = "cantango-core"
-  s.version = "0.1.3"
+  s.name = %q{cantango-core}
+  s.version = "0.1.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Kristian Mandrup", "Stanislaw Pankevich"]
-  s.date = "2011-12-01"
-  s.description = "Define your permission rules as role- or role group specific permits.\nIntegrates well with multiple Devise user acounts.\nIncludes rules caching.\nStore permissions in yaml file or key-value store"
-  s.email = "kmandrup@gmail.com, s.pankevich@gmail.com"
+  s.authors = [%q{Kristian Mandrup}, %q{Stanislaw Pankevich}]
+  s.date = %q{2011-12-03}
+  s.description = %q{Define your permission rules as role- or role group specific permits.
+Integrates well with multiple Devise user acounts.
+Includes rules caching.
+Store permissions in yaml file or key-value store}
+  s.email = %q{kmandrup@gmail.com, s.pankevich@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE.txt",
     "README.mdown"
@@ -28,17 +31,21 @@ Gem::Specification.new do |s|
     "cantango-core.gemspec",
     "lib/cantango/ability.rb",
     "lib/cantango/ability/base.rb",
-    "lib/cantango/ability/base/callbacks.rb",
     "lib/cantango/ability/cache.rb",
     "lib/cantango/ability/cache/simple_key.rb",
+    "lib/cantango/ability/callbacks.rb",
     "lib/cantango/ability/executor.rb",
     "lib/cantango/ability/executor/base.rb",
-    "lib/cantango/ability/executor/modes.rb",
-    "lib/cantango/ability/executor/no_cache_mode.rb",
+    "lib/cantango/ability/executor/modal.rb",
     "lib/cantango/ability/helper.rb",
     "lib/cantango/ability/helper/account.rb",
     "lib/cantango/ability/helper/engine.rb",
     "lib/cantango/ability/helper/user.rb",
+    "lib/cantango/ability/mode.rb",
+    "lib/cantango/ability/mode/base.rb",
+    "lib/cantango/ability/mode/finder.rb",
+    "lib/cantango/ability/mode/no_cache.rb",
+    "lib/cantango/ability/rules.rb",
     "lib/cantango/adaptor.rb",
     "lib/cantango/adaptor/active_record.rb",
     "lib/cantango/adaptor/data_mapper.rb",
@@ -70,15 +77,22 @@ Gem::Specification.new do |s|
     "lib/generators/cantango/install/templates/cantango.rb",
     "lib/generators/cantango/install/templates/categories.yml",
     "lib/generators/cantango/install/templates/permissions.yml",
+    "spec/active_record/001_create_posters.rb",
+    "spec/active_record/002_create_users.rb",
     "spec/cantango/ability/base_spec.rb",
     "spec/cantango/ability/cache/simple_key_spec.rb",
+    "spec/cantango/ability/callbacks_spec.rb",
     "spec/cantango/ability/executor/base_spec.rb",
     "spec/cantango/ability/executor/custom_spec.rb",
-    "spec/cantango/ability/executor/modes_spec.rb",
-    "spec/cantango/ability/executor/no_cache_mode_spec.rb",
+    "spec/cantango/ability/executor/modal_spec.rb",
+    "spec/cantango/ability/executor_spec.rb",
     "spec/cantango/ability/helper/account_spec.rb",
     "spec/cantango/ability/helper/engine_spec.rb",
     "spec/cantango/ability/helper/user_spec.rb",
+    "spec/cantango/ability/mode/base_example.rb",
+    "spec/cantango/ability/mode/base_spec.rb",
+    "spec/cantango/ability/mode/no_cache_spec.rb",
+    "spec/cantango/ability/rules_spec.rb",
     "spec/cantango/adaptor/active_record_spec.rb",
     "spec/cantango/adaptor/data_mapper_spec.rb",
     "spec/cantango/adaptor/mongo_mapper_spec.rb",
@@ -93,20 +107,23 @@ Gem::Specification.new do |s|
     "spec/cantango/rspec/be_allowed_to_spec.rb",
     "spec/cantango/scope/ability_spec.rb",
     "spec/cantango_spec.rb",
+    "spec/db/database.yml",
     "spec/fixtures/models.rb",
     "spec/fixtures/models/account.rb",
     "spec/fixtures/models/admin.rb",
     "spec/fixtures/models/admin_account.rb",
     "spec/fixtures/models/items.rb",
     "spec/fixtures/models/user.rb",
+    "spec/fixtures/test.yml",
     "spec/generators/cantango/install_generator_spec.rb",
+    "spec/migration_helper.rb",
     "spec/spec_helper.rb"
   ]
-  s.homepage = "http://github.com/kristianmandrup/cantango"
-  s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.10"
-  s.summary = "CanCan extension with role oriented permission management and more"
+  s.homepage = %q{http://github.com/kristianmandrup/cantango}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.6}
+  s.summary = %q{CanCan extension with role oriented permission management and more}
 
   if s.respond_to? :specification_version then
     s.specification_version = 3

data/lib/cantango/ability/base.rb

@@ -1,74 +1,30 @@
 module CanTango
   module Ability
     class Base
-      autoload_modules :Callbacks
-      
       include CanCan::Ability
-
-      attr_reader :options, :candidate
+      include CanTango::Ability::Rules
+      
+      attr_reader :candidate, :options
 
       # Equivalent to a CanCan Ability#initialize call
       # which executes all the permission logic
       def initialize candidate, options = {}
         raise "Candidate must be something!" if !candidate
         @candidate, @options = candidate, options
-        execute!
       end
       
-      def execute!
-        within_callbacks do
-          clear_rules!
-          permit_rules
-        end        
-      end
-
-      def within_callbacks &block
-        yield
-      end
-
-      # overriden by Engine helper
-      def engines_on?
-        false
-      end
-
-      def cached?
-        false
+      def execute
+        clear_rules!
+        calculate_rules
       end
-
-      def rules
-        @rules
-      end
-
-      # developer can add rules here to be included in all subclasses!
-      def permit_rules
-      end
-
-      def clear_rules!
-        @rules ||= default_rules
-      end
-
+      
       def session
-        @session = options[:session] || {} # seperate session cache for each type of user?
-      end
-
-      # overriden by Masquerade helper
-      def subject
-        candidate
-      end
-
-      def config
-        CanTango.config
+        @session ||= options[:session] || {} # seperate session cache for each type of user?
       end
 
       # Helper.modules.each do |name|
         # include "CanTango::Ability::Helper::#{name.to_s.camelize}".constantize
       # end
-    
-      protected
-
-      def default_rules
-        []
-      end
     end
   end
 end

data/lib/cantango/ability/cache/simple_key.rb

@@ -4,6 +4,7 @@ module CanTango
       class SimpleKey
         attr_reader :user, :subject
 
+        # FIX: do we really need both user and subject? how about just candidate!
         def initialize user, subject = nil
           @user = user
           @subject = subject || user

data/lib/cantango/ability/callbacks.rb

@@ -0,0 +1,36 @@
+module CanTango::Ability
+  module Callbacks
+    include CanTango::Helpers::Debug
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      [:after, :before].each do |type|
+        class_eval %{
+          def #{type}_execute_callbacks
+            @#{type}_execute_callbacks ||= []
+          end
+
+          def #{type}_execute *callbacks
+            @#{type}_execute_callbacks = callbacks.flatten
+          end
+        }
+      end
+    end
+    
+    # should execute :after_execute callbacks
+    def handle_callbacks type
+      callbacks_method = "#{type}_execute_callbacks"
+      raise ArgumentError, "Not a valid callback type: #{type}" if !self.class.respond_to? callbacks_method
+      self.class.send(callbacks_method).each {|callback| send(callback) }
+    end
+
+    def within_callbacks &block
+      handle_callbacks :before
+      yield
+      handle_callbacks :after
+    end
+  end
+end

data/lib/cantango/ability/executor/base.rb

@@ -1,53 +1,28 @@
-module CanTango
-  module Ability
-    module Executor
-      class Base
-        include CanTango::Helpers::Debug
+module CanTango::Ability::Executor
+  class Base
+    include CanTango::Ability::Executor
+    include CanTango::Ability::Callbacks
 
-        delegate :session, :user, :subject, :candidate, :cached?, :to => :ability
+    attr_reader :candidate, :modes, :options
 
-        def execute!
-          return if !valid?
-          start_execute
-          return if cached? # rule set already loaded
-
-          clear_rules!
-          permit_rules
-
-          end_execute
-          rules # return rule set
-        end
-
-        def rules
-          @rules ||= []
-        end
-
-        def clear_rules!
-          @rules ||= []
-        end
-
-        def permit_rules
-          raise NotImplementedError
-        end
-
-        def cached?
-          false
-        end
-
-        protected
-
-        def start_execute
-          debug "Executing base Ability"
-        end
+    def initialize candidate, options = {}
+      raise ArgumentError, "Candidate must be something!" if !candidate
+      @candidate, @options = [candidate, options]
+    end
 
-        def end_execute
-          debug "DONE"
-        end
+    def rules
+      raise NotImplementedError
+    end
+    
+    def calculate_rules
+      raise NotImplementedError
+    end
 
-        def key_method_names
-          []
-        end
-      end
+    def self.inherited(base)
+      base.send :include, CanTango::Helpers::Debug
+      base.send :include, CanTango::Ability::Executor
+      base.send :include, CanTango::Ability::Rules
+      base.send :include, CanTango::Ability::Callbacks
     end
   end
 end

data/lib/cantango/ability/executor/modal.rb

@@ -0,0 +1,46 @@
+module CanTango::Ability::Executor
+  class Modal < Base    
+    def initialize candidate, modes, options = {}
+      super candidate, options
+      modes = [modes].flatten if modes
+      raise ArgumentError, "Modes must be a list of modes to execute!" if modes.blank?
+      @modes = modes
+    end
+
+    def calculate_rules
+      @rules = modes.inject([]) do |result, mode|
+        result = result + modal_rules(mode)
+        result
+      end
+      normalize_rules!
+    end
+
+    def execute
+      clear_rules!
+      calculate_rules
+      return rules
+    rescue Exception => e
+      debug e.message
+      rules
+    end
+
+    def finder
+      @finder ||= CanTango::Ability::Mode::Finder.new self
+    end
+
+    protected
+
+    def modal_rules mode
+      puts "modal rules: #{mode}"
+      mode?(mode) ? executor(mode).execute : []
+    end
+
+    def executor mode
+      @executor ||= finder.executor_for(mode)
+    end
+
+    def mode? mode
+      modes.include?(mode)
+    end
+  end
+end

data/lib/cantango/ability/executor.rb

@@ -1,7 +1,30 @@
 module CanTango
   module Ability
     module Executor
-      autoload_modules :Base, :NoCacheMode, :Modes
+      autoload_modules :Base, :Modal
+
+      include CanTango::Helpers::Debug
+
+      include CanTango::Ability::Rules
+      include CanTango::Ability::Callbacks
+
+      def self.included(base)
+        base.send :include, CanTango::Helpers::Debug
+        base.send :include, CanTango::Ability::Rules
+        base.send :include, CanTango::Ability::Callbacks
+      end
+
+      # the way to abort execution is to raise an exception!
+      def execute
+        within_callbacks do
+          clear_rules!
+          calculate_rules
+        end
+        return rules
+      rescue Exception => e
+        debug e.message
+        rules
+      end
     end
   end
 end

data/lib/cantango/ability/mode/base.rb

@@ -0,0 +1,32 @@
+module CanTango
+  module Ability
+    module Mode
+      class InvalidError < StandardError; end
+      
+      class Base
+        include CanTango::Ability::Executor
+
+        attr_reader :ability
+
+        delegate :session, :user, :subject, :candidate,   :to => :ability
+        delegate :can, :cannot, :can?, :cannot?, :rules,  :to => :ability
+
+        def initialize ability, options = {}
+          @ability, @options = [ability, options]
+        end
+
+        def within_callbacks
+          handle_callbacks :before
+          raise CanTango::Ability::Mode::InvalidError, "Not  valid mode: #{self.class}" if !valid?
+          yield
+          handle_callbacks :after
+          rules
+        end
+
+        def valid?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/cantango/ability/mode/finder.rb

@@ -0,0 +1,19 @@
+module CanTango::Ability::Mode
+  class Finder
+    attr_reader :executor
+
+    delegate :candidate, :options, :to => :executor
+
+    def initialize executor
+      @executor = executor
+    end
+
+    def executor_for mode
+      class_for(mode).new candidate, options
+    end
+
+    def class_for mode
+      "CanTango::Ability::Mode::#{mode.to_s.camelize}".constantize
+    end
+  end
+end

data/lib/cantango/ability/mode/no_cache.rb

@@ -0,0 +1,8 @@
+module CanTango
+  module Ability
+    module Mode
+      class NoCache < Base
+      end
+    end
+  end
+end

data/lib/cantango/ability/mode.rb

@@ -0,0 +1,7 @@
+module CanTango
+  module Ability
+    module Mode
+      autoload_modules :Base, :NoCache, :Finder
+    end
+  end
+end

data/lib/cantango/ability/rules.rb

@@ -0,0 +1,24 @@
+module CanTango::Ability
+  module Rules
+    def calculate_rules
+      rules
+    end
+
+    def normalize_rules!
+      rules.flatten!
+      rules.compact!
+    end
+
+    def rules
+      @rules ||= []
+    end
+
+    def clear_rules!
+      rules = default_rules
+    end
+
+    def default_rules
+      []
+    end
+  end
+end

data/lib/cantango/ability.rb

@@ -1,10 +1,5 @@
 module CanTango
   module Ability
-    autoload_modules :Base, :Cache, :Executor, :Helper
-    
-    # by default add callbacks?
-    class Base
-      include Callbacks
-    end
+    autoload_modules :Rules, :Callbacks, :Executor, :Base, :Cache, :Helper, :Mode
   end
 end

data/lib/cantango/adaptor/active_record.rb

@@ -1,6 +1,6 @@
 module CanTango::Adaptor
   module ActiveRecord
-    include CanTango::Rules::Adaptor::Relational
+    include CanTango::Adaptor::Relational
   end
 end
 

data/lib/cantango/adaptor/data_mapper.rb

@@ -1,5 +1,5 @@
 module CanTango::Adaptor
   module DataMapper
-    include CanTango::Rules::Adaptor::Relational
+    include CanTango::Adaptor::Relational
   end
 end

data/lib/cantango/adaptor/mongo.rb

@@ -1,6 +1,6 @@
 module CanTango::Adaptor
   module Mongo
-    #include CanTango::Rules::Adaptor::Generic
+    #include CanTango::daptor::Generic
     # using #in on Hash (Mongoid query)
     def include_condition attribute, candidate
       { attribute.to_sym.in => candidate.send(attribute) }

data/lib/cantango/adaptor/mongo_mapper.rb

@@ -1,5 +1,5 @@
 module CanTango::Adaptor
   module MongoMapper
-    include module CanTango::Rules::Adaptor::Mongo
+    include CanTango::Adaptor::Mongo
   end
 end

data/lib/cantango/adaptor/mongoid.rb

@@ -1,5 +1,5 @@
 module CanTango::Adaptor
   module Mongoid
-    include module CanTango::Rules::Adaptor::Mongo
+    include CanTango::Adaptor::Mongo
   end
 end

data/lib/cantango/adaptor.rb

@@ -1,36 +1,34 @@
 module CanTango
-  module Rules
-    module Adaptor
-      autoload_modules :Generic, :Relational, :Mongo
-      autoload_modules :ActiveRecord, :DataMapper, :Mongoid, :MongoMapper
+  module Adaptor
+    autoload_modules :Generic, :Relational, :Mongo
+    autoload_modules :ActiveRecord, :DataMapper, :Mongoid, :MongoMapper
 
-      # include adaptor depending on which ORM the object inherits from or includes
-      def use_adaptor! base, object
-        orm_map.each_pair do |orm, const|
-          begin
-            base.class.send :include, get_adapter(object, const.constantize, orm)
-          rescue
-            next
-          end
+    # include adaptor depending on which ORM the object inherits from or includes
+    def use_adaptor! base, object
+      orm_map.each_pair do |orm, const|
+        begin
+          base.class.send :include, get_adapter(object, const.constantize, orm)
+        rescue
+          next
         end
       end
+    end
 
-      def get_adapter object, adaptor_class, orm
-        object.kind_of?(adaptor_class) ? adaptor_for(orm) : adaptor_for(:generic)
-      end
+    def get_adapter object, adaptor_class, orm
+      object.kind_of?(adaptor_class) ? adaptor_for(orm) : adaptor_for(:generic)
+    end
 
-      def adaptor_for orm
-        "CanTango::Rules::Adaptor::#{orm.to_s.camelize}".constantize
-      end
+    def adaptor_for orm
+      "#{self.class}::#{orm.to_s.camelize}".constantize
+    end
 
-      def orm_map
-        {
-          :active_record  => "ActiveRecord::Base",
-          :data_mapper    => "DataMapper::Resource",
-          :mongoid        => "Mongoid::Document",
-          :mongo_mapper   => "MongoMapper::Document"
-        }
-      end
+    def orm_map
+      {
+        :active_record  => "ActiveRecord::Base",
+        :data_mapper    => "DataMapper::Resource",
+        :mongoid        => "Mongoid::Document",
+        :mongo_mapper   => "MongoMapper::Document"
+      }
     end
   end
 end