cantango-core 0.1.0

data/lib/cantango/rails.rb

@@ -0,0 +1,7 @@
+module CanTango
+  module Rails
+    module Helpers
+      autoload_modules :ControllerHelper, :ViewHelper, :BaseHelper, :RestHelper
+    end
+  end
+end

data/lib/cantango/rails/engine.rb

@@ -0,0 +1,63 @@
+module CanTango
+  # Include helpers in the given scope to AC and AV.
+  # "Borrowed" from devise
+  def self.include_helpers(scope)
+    # Seems like the order of initializers is important! ActiveRecord should go first!
+    ActiveSupport.on_load(:active_record) do
+      RailsAutoLoader.load_models! if CanTango.config.autoload.models?
+    end
+
+    ActiveSupport.on_load(:action_controller) do
+      include scope::Rails::Helpers::ControllerHelper
+    end
+
+    ActiveSupport.on_load(:action_view) do
+      include scope::Rails::Helpers::ViewHelper
+    end
+  end
+
+  # http://edgeguides.rubyonrails.org/configuring.html
+  # - before_configuration: This is run as soon as the application constant inherits from Rails::Application. The config calls are evaluated before this happens.
+  # - before_initialize: This is run directly before the initialization process of the application occurs with the :bootstrap_hook initializer near the beginning of the Rails initialization process.
+  # - to_prepare: Run after the initializers are ran for all Railties (including the application itself), but before eager loading and the middleware stack is built. More importantly, will run upon every request in development, but only once (during boot-up) in production and test.
+  # - before_eager_load: This is run directly before eager loading occurs, which is the default behaviour for the production environment and not for the development environment.
+  # - after_initialize: Run directly after the initialization of the application, but before the application initializers are run.
+  class RailsEngine < ::Rails::Engine
+    initializer "cantango.helpers" do
+      CanTango.include_helpers(CanTango)
+
+      # load all models
+      # this is needed in order to register all users and accounts with CanTango using the user/account macros!
+    end
+
+    config.to_prepare do
+      CanTango.to_prepare
+
+      # load all permits (development mode: EVERY request!)
+      RailsAutoLoader.load_permits! if CanTango.config.autoload.permits?
+    end
+
+    config.after_initialize do
+      CanTango.after_initialize
+    end
+  end
+
+  module RailsAutoLoader
+    def self.load_models!
+      load_files! :models
+    end
+
+    def self.load_permits!
+      load_files! :permits
+    end
+
+    private
+
+    def self.load_files! path
+      Dir[::Rails.root + "app/#{path}/**/*.rb"].each do |path|
+        require_dependency path
+      end
+    end
+  end
+end
+

data/lib/cantango/rails/helpers/base_helper.rb

@@ -0,0 +1,29 @@
+module CanTango
+  module Rails
+    module Helpers
+      module BaseHelper
+        def self.included(base)
+          include_apis(base)
+          # base.send :include, CanTango::Rails::Helpers::RestHelper
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          def include_apis(clazz)
+            return if !respond_to?(:apis) || !apis
+            apis.each do |api|
+              # puts "include API: #{api}"
+              clazz.send :include, "CanTango::Api::User::#{api}".constantize
+              clazz.send :include, "CanTango::Api::UserAccount::#{api}".constantize
+            end
+          end
+
+          def apis
+            [:Can, :Scope, :Ability, :Session]
+          end
+        end
+        extend ClassMethods
+      end
+    end
+  end
+end

data/lib/cantango/rails/helpers/controller_helper.rb

@@ -0,0 +1,17 @@
+module CanTango
+  module Rails
+    module Helpers
+      module ControllerHelper
+        include CanTango::Rails::Helpers::BaseHelper
+
+        def self.included(base)
+          include_apis(self)
+        end
+
+        def self.apis
+          [] # [:Can, :Active, :Scope]
+        end
+      end
+    end
+  end
+end

data/lib/cantango/rails/helpers/rest_helper.rb

@@ -0,0 +1,76 @@
+module CanTango::Rails::Helpers::RestHelper
+  CanTango.config.models.actions.registered.each_pair do |model, actions|
+    actions.actions_for :member do |member_action|
+      class_eval %{
+        def #{member_action}_#{model.to_s.underscore}_path obj, options = {}
+          return unless can_perform_action?(user_type, :#{member_action}, obj)
+          # use i18n translation on label
+          link_to t(".#{member_action}"), rest_obj_action(obj, :#{member_action}, options)
+        end
+      }
+    end
+
+    actions.actions_for :collection do |collection_action|
+      class_eval %{
+        def #{collection_action}_#{model.to_s.underscore}_path obj, options = {}
+          clazz = obj.kind_of?(Class) ? obj : obj.class
+          return unless can_perform_action?(user_type, :#{collection_action}, clazz)
+          # use i18n translation on label
+          link_to t(".#{collection_action}"), send(action_method clazz, :#{collection_action}, options)
+        end
+      }
+    end
+  end
+
+  CanTango.config.models.available_models.each do |model|
+    class_eval %{
+      def delete_#{model.to_s.underscore}_path obj, options = {}
+        #{model}_path obj, {:method => 'delete'}.merge(options)
+      end
+    }
+  end
+
+  def link_to_new obj, user_type, options = {}
+    clazz = obj.kind_of?(Class) ? obj : obj.class
+    return unless can_perform_action?(user_type, :create, clazz)
+    # use i18n translation on label
+    link_to t(".create"), send(action_method clazz, :new, options)
+  end
+
+  def link_to_delete obj, user_type, options = {}
+    return unless can_perform_action?(user_type, :delete, obj)
+    # use i18n translation on label
+    link_to t(".delete"), rest_obj_action(obj, :delete, options)
+  end
+
+  def link_to_edit obj, user_type, options = {}
+    return unless can_perform_action?(user_type, :edit, obj)
+    # use i18n translation on label
+    link_to t(".edit"), rest_obj_action(obj, :edit, options)
+  end
+
+  def link_to_view obj, user_type, options = {}
+    return unless can_perform_action?(user_type, :view, obj)
+    # use i18n translation on label
+    link_to t(".view"), send(view_method(obj), obj, options)
+  end
+
+  protected
+
+  def can_perform_action? user_type, action, obj
+    send(:"#{user_type}_can?", action, obj)
+  end
+
+  def view_method obj
+    "#{obj.class.to_s.underscore}_path"
+  end
+
+  def rest_obj_action obj, action, options
+    send action_method(obj, :edit), obj, options
+  end
+
+  def action_method obj, action
+    "#{action}_#{obj.class.to_s.underscore}_path"
+  end
+end
+

data/lib/cantango/rails/helpers/view_helper.rb

@@ -0,0 +1,17 @@
+module CanTango
+  module Rails
+    module Helpers
+      module ViewHelper
+        include CanTango::Rails::Helpers::BaseHelper
+
+        def self.included(base)
+          include_apis(self)
+        end
+
+        def self.apis
+          [] # [:Can, :Active, :Scope]
+        end
+      end
+    end
+  end
+end

data/lib/cantango/rails/railtie.rb

@@ -0,0 +1,7 @@
+module CanTango
+  class Railtie < Rails::Railtie
+    initializer "cantango" do |app|
+      # puts "initializing CanTango..."
+    end
+  end
+end

data/lib/cantango/rspec.rb

@@ -0,0 +1 @@
+require 'cantango/rspec/config'

data/lib/cantango/rspec/config.rb

@@ -0,0 +1,3 @@
+require 'rspec'
+require 'code-spec'
+require 'cantango/rspec/matchers'

data/lib/cantango/rspec/matchers.rb

@@ -0,0 +1 @@
+require 'cantango/rspec/matchers/be_allowed_to'

data/lib/cantango/rspec/matchers/be_allowed_to.rb

@@ -0,0 +1,28 @@
+# http://solnic.eu/2011/01/14/custom-rspec-2-matchers.html
+
+
+RSpec::Matchers.define :be_allowed_to do |action, objects|
+  chain :with_options do |options|
+    @options = options
+  end
+
+  match do |subject|
+    @options ? subject.can?(action, objects, @options) : subject.can?(action, objects)
+  end
+
+  failure_message_for_should do |subject|
+    %{expected that #{subject} could #{action} the #{objects}
+#{subject.send :rules}}
+  end
+
+  failure_message_for_should_not do |actual|
+    %{did not expect that #{subject} could #{action} the #{objects}
+#{subject.send :rules}}
+  end
+
+  description do
+    "be allowed to #{action} the #{objects}"
+  end
+end
+
+

data/lib/cantango/rules.rb

@@ -0,0 +1,8 @@
+module CanTango
+  module Rules
+    autoload_modules :Adaptor, :Dsl, :RuleClass, :Scope, :Relation
+
+    include Dsl
+    include CanCan::Ability
+  end
+end

data/lib/cantango/rules/adaptor.rb

@@ -0,0 +1,37 @@
+module CanTango
+  module Rules
+    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
+        end
+      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 orm_map
+        {
+          :active_record => "ActiveRecord::Base",
+          :data_mapper => "DataMapper::Resource",
+          :mongoid => "Mongoid::Document",
+          :mongo_mapper => "MongoMapper::Document"
+        }
+      end
+    end
+  end
+end
+

data/lib/cantango/rules/adaptor/active_record.rb

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

data/lib/cantango/rules/adaptor/data_mapper.rb

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

data/lib/cantango/rules/adaptor/generic.rb

@@ -0,0 +1,16 @@
+module CanTango
+  module Rules
+    module Adaptor
+      module Generic
+
+        def attribute_condition attribute, user_scope
+          Proc.new { |model| model.send(attribute) == user_scope }
+        end
+
+        def include_condition attribute, user_scope
+          Proc.new { |model| model.send(attribute).include? user_scope }
+        end
+      end
+    end
+  end
+end

data/lib/cantango/rules/adaptor/mongo.rb

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

data/lib/cantango/rules/adaptor/mongo_mapper.rb

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

data/lib/cantango/rules/adaptor/mongoid.rb

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

data/lib/cantango/rules/adaptor/relational.rb

@@ -0,0 +1,13 @@
+module CanTango
+  module Rules
+    module Adaptor
+      module Relational
+        def attribute_condition attribute, user_scope
+          { attribute.to_sym => user_scope.send(attribute) }
+        end
+        alias_method :include_condition, :attribute_condition
+      end
+    end
+  end
+end
+

data/lib/cantango/rules/dsl.rb

@@ -0,0 +1,24 @@
+module CanTango
+  module Rules
+    module Dsl
+      def self.included(base)
+        ::CanTango.config.user.relations.each do |relationship|
+          base.class_eval %{
+            def #{relationship}_of *models, &block
+              options = models.extract_options!
+              scope = options[:scope] || :user_account
+              relation = UserRelation.new :#{relationship}, self, scope, *models, &block
+              yield relation if block
+              relation
+            end
+          }
+        end
+      end
+
+      # creates a scope that enforces either using the user or user_account for determining relationship matches on the models
+      def scope name, &block
+        yield CanTango::Rules::Scope.new name, self, &block
+      end
+    end
+  end
+end