cantango-config 0.1.9.2 → 0.2.0

data/lib/cantango/configuration.rb

@@ -1,110 +0,0 @@
-require 'set'
-require 'singleton'
-
-require 'cantango/configuration'
-
-module CanTango
-  # The main entry point to configure CanTango
-  class << self
-    def configure &block
-      conf = CanTango::Configuration.instance
-      yield conf if block
-      conf
-    end
-
-    alias_method :config, :configure
-  end
-  
-  class Configuration
-    autoload_modules :Models, :Registry, :Engines, :Factory, :ExecutionModes, :Modes, :Ability
-    autoload_modules :Categories, :Category
-    autoload_modules :Autoload, :Adapters, :Debug, :Orms, :Localhosts, :Hooks
-    autoload_modules :Account, :Accounts
-    autoload_modules :User, :Guest, :Users
-
-    include Singleton
-
-    def ability
-      @ability ||= conf::Ability.instance
-      @ability.default_class ||= CanTango::Ability::Executor::Modal # from cantango-core
-      @ability
-    end
-
-    def self.components
-      [
-        :guest, :autoload, :user, :account, :models, :modes, :roles, :role_groups,
-        :engines, :users, :accounts, :categories, :adapters, :debug,
-        :localhosts, :orms, :hooks
-      ]
-    end
-
-    components.each do |conf_module|
-      class_eval %{
-        def #{conf_module} &block
-          conf = conf::#{conf_module.to_s.camelize}.instance
-          yield conf if block
-          conf
-        end
-      }
-    end
-
-    def debug!
-      debug.set :on
-    end
-
-    # Turn on default engines and enable compile adapter 
-    # i.e compilation of rules via sourcify
-    def enable_defaults!
-      engines.all :off
-      adapters.use :compiler
-    end
-
-    def enable_helpers *names
-      names = names.to_symbols
-      enable_rest_helper if names.include? :rest
-    end
-
-    def enable_rest_helper
-      raise 'ApplicationController not defined' if !defined?(::ApplicationController)
-      ::ApplicationController.send :include, CanTango::Rails::Helpers::RestHelper
-    end
-
-    def clear!
-      CanTango::Configuration.components.each do |component|
-        if respond_to? component
-          component = send(component) 
-          component.send(:clear!) if component.respond_to? :clear!
-        end
-      end
-      engines.clear!
-    end
-
-    def include_models *names
-      names = names.select_symbols
-      if names.include? :default_guest_user
-        require 'cantango/user/guest'
-      end
-    end
-
-    # allow either block or direct access
-    # engine(:permission) do |permission|
-    # engine(:permission).config_path
-    def engine name, &block
-      engine = find_engine(name)
-      yield engine if block
-      engine
-    end
-
-    protected
-
-    def find_engine name
-      raise ArgumentError, "Must be label for an engine" if !name.kind_of_label?
-      name = name.to_s.singularize
-      engines.send(name) if engines.available? name
-    end
-
-    def conf
-      CanTango::Configuration
-    end
-  end
-end

data/lib/cantango/configuration/category.rb

@@ -1,20 +0,0 @@
-module CanTango
-  class Configuration
-    class Category
-      def initialize *subjects
-        @subjects = subjects.flatten
-      end
-
-      def subjects
-        @subjects ||= []
-      end
-
-      # test if a particular category has a certain subject
-      def has_any? subject, &block
-        found = subjects.include? subject
-        yield if found && block
-        found
-      end
-    end
-  end
-end

data/lib/cantango/configuration/engine.rb

@@ -1,33 +0,0 @@
-require 'singleton'
-
-module CanTango
-  class Configuration
-    class Engine
-      include Singleton
-      include CanTango::Configuration::ExecutionModes
-
-      def set state = :on
-        raise ArgumentError, "Must be :on or :off" unless !state || [:on, :off].include?(state)
-        @state = state || :on
-      end
-
-      def reset!
-        @state = nil
-      end
-
-      def on?
-        @state == :on
-      end
-
-      def off?
-        !on?
-      end
-
-      protected
-
-      def ns
-        CanTango::Configuration::Engines
-      end
-    end
-  end
-end

data/lib/cantango/configuration/engines.rb

@@ -1,95 +0,0 @@
-module CanTango
-  class Configuration
-    class Engines < Registry::Hash
-      include Singleton
-      include Enumerable
-
-      # engine registry is a simple hash
-      def register hash
-        hash.each_pair do |name, engine_class|
-          raise "Class must implement the CanTango Engine API. You can start by sublclassing CanTango::Engine" if !engine? engine_class
-          raise "Name of engine must be a String or Symbol" if !name.kind_of_label?
-          registered[name.to_s] = engine_class
-        end
-      end
-
-      # defines the order of execution of engine in ability
-      def set_execution_order *names        
-        @execution_order = names.flatten.uniq.map(&:to_s).select {|name| available? name }
-      end
-
-      def dont_execute name
-        execution_order.delete(name.to_s)
-      end
-
-      def execute_first name
-        dont_execute name
-        execution_order.insert(0, name.to_s)
-      end
-
-      def execute_last name
-        dont_execute name
-        execution_order.insert(-1, name.to_s)
-      end
-
-      def execute_before existing, name
-        dont_execute name
-        index = execution_order.index(existing.to_s) || 0
-        execution_order.insert(index, name.to_s)
-        execution_order.compact!
-      end
-
-      def execute_after existing, name
-        dont_execute name
-        index = execution_order.index(existing.to_s)
-        index ? execution_order.insert(index +1, name.to_s) : execute_last(name)
-        execution_order.compact!
-      end
-
-      def execution_order
-        @execution_order ||= (available - [:cache])
-      end
-
-      def available
-        registered_names
-      end
-
-      def available? name
-        available.include? name.to_s
-      end
-
-      def all state
-        available.each {|engine| send(engine).set state }
-      end
-
-      def any? state
-        available.any? {|engine| send(engine).send(:"#{state}?") if respond_to?(engine) }
-      end
-
-      def clear!
-        each {|engine| engine.reset! }
-        @registered = nil
-        @execution_order = nil
-      end
-
-      def each
-        available.each {|engine| yield send(engine) if respond_to?(engine) }
-      end
-
-      def active? name
-        active.include? name.to_sym
-      end
-
-      def active
-        available.select {|engine| send(engine).on? if respond_to?(engine) }
-      end
-
-      protected
-
-      # does it implement the basic Engine API?
-      def engine? engine_class
-        [:execute!, :ability].all? {|meth| engine_class.instance_methods.include? meth }
-      end
-    end
-  end
-end

data/lib/cantango/configuration/execution_modes.rb

@@ -1,21 +0,0 @@
-module CanTango
-  class Configuration
-    module ExecutionModes
-      def modes
-        @modes ||= [:no_cache]
-      end
-
-      def mode= mode_name
-        mode_name = mode_name.to_sym
-        raise ArgumentError, "Not a valid mode name" if !valid_mode_names.include? mode_name
-        @modes = (mode_name == :both) ? [:cache, :no_cache] : [mode_name]
-      end
-
-      private
-
-      def valid_mode_names
-        [:cache, :no_cache]
-      end
-    end
-  end
-end

data/lib/cantango/configuration/modes.rb

@@ -1,8 +0,0 @@
-module CanTango
-  class Configuration
-    class Modes < Registry::Clazz
-      include Singleton
-    end
-  end
-end
-

data/lib/cantango/configuration/registry.rb

@@ -1,7 +0,0 @@
-module CanTango
-  class Configuration
-    module Registry
-      autoload_modules :Base, :Hash, :Clazz
-    end
-  end
-end

data/lib/cantango/configuration/registry/clazz.rb

@@ -1,94 +0,0 @@
-require 'singleton'
-require 'sugar-high/kind_of'
-
-module CanTango
-  class Configuration
-    module Registry
-      class Clazz
-        def register label, value
-          raise "first arg must be a label, was: #{label}" if !label.kind_of_label?
-          raise "second arg must be a valid Class, was: #{value}" if !valid? value
-          name_registry.register label.to_sym
-          class_registry.register value
-        end
-        alias_method :[]=, :register
-
-        def << hash
-          raise "Must be a hash" if !hash.is_a?(::Hash)
-          hash.each_pair do |key, value|
-            register key, value
-          end
-        end
-
-        def registered
-          name_registry.registered
-        end
-        alias_method :registered_names, :registered
-
-        def clean!
-          name_registry.clean!
-          class_registry.clean!
-        end
-        alias_method :clear!, :clean!
-
-        def registered_classes
-          class_registry.registered
-        end
-
-        def registered? name
-          name_registry.registered? name
-        end
-
-        def registered_class? name
-          class_registry.registered? name
-        end
-
-        def name_registry
-          @name_registry ||=NameRegistry.new
-        end
-
-        def class_registry
-          @class_registry ||= ClassRegistry.new
-        end
-
-        def value_methods
-          class_registry.value_methods
-        end
-
-        def value_types
-          class_registry.types
-        end
-
-        class NameRegistry < Registry::Base
-        end
-
-        class ClassRegistry < Registry::Base
-
-          def types
-            [Class]
-          end
-        
-          def value_methods
-            []
-          end
-        end
-      
-        protected
-      
-        def valid? value
-          valid_by_type?(value) && valid_by_methods?(value)
-        end
-      
-        def valid_by_type? value
-          return true if value_types.blank?
-          value.any_kind_of?(*value_types)
-        end
-      
-        def valid_by_methods? value
-          return true if value_methods.blank?
-          value_methods.all?{|m| value.respond_to(m)}
-        end
-      end
-    end
-  end
-end

data/spec/cantango/configuration/execution_modes_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-require 'cantango/configuration/shared/execution_modes_ex'
-
-class User
-end
-
-class MyAbility
-  include CanTango::Configuration::ExecutionModes
-end
-
-describe CanTango::Configuration::ExecutionModes do
-  subject { MyAbility.new }
-
-  it_should_behave_like "Execution Modes"
-end

data/spec/cantango/configuration/localhosts_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-require 'cantango/configuration/shared/registry/base_ex'
-
-describe CanTango::Configuration::Localhosts do
-  subject { CanTango.config.localhosts }
-
-  it_should_behave_like "Registry" do
-  end
-end

data/spec/cantango/configuration/shared/execution_modes_ex.rb

@@ -1,14 +0,0 @@
-shared_examples_for 'Execution Modes' do
-  describe 'valid mode=' do
-    before do
-      subject.mode = :cache
-    end
-    specify { subject.modes.should == [:cache] }
-  end
-
-  describe 'invalid mode=' do
-    specify do
-      lambda { subject.mode = :cachy! }.should raise_error
-    end
-  end
-end

data/spec/cantango/configuration_spec.rb

@@ -1,112 +0,0 @@
-require 'spec_helper'
-require 'fixtures/models'
-
-@user = User.new('kris', 'kris@gmail.com')
-
-class CanTango::CustomAbility < CanTango::Ability::Base
-  def initialize candidate, options = {}
-    'custom'
-  end
-end
-
-class ApplicationController
-end
-
-describe CanTango::Configuration do
-  subject { CanTango.config }
-
-  describe 'ability' do
-    specify { subject.ability.should be_a CanTango::Configuration::Ability }
-  end
-
-  describe 'hooks' do
-    specify { subject.hooks.registered.should be_empty }
-
-    describe 'register hooks' do
-      before do
-        subject.hooks.register :nime => Proc.new { 2 }
-      end
-      specify { subject.hooks.registered.should_not be_empty }
-      specify { subject.hooks[:nime].should be_a Proc }
-    end
-  end
-
-  describe 'include_models :default_guest_user' do
-    before do
-      subject.include_models :default_guest_user
-    end
-    specify { defined?(::Guest).should be_true }
-  end
-
-  describe 'enable defaults' do
-    before do
-      subject.enable_defaults!
-    end
-    specify { subject.engine(:permit).should be_nil }
-    specify { subject.engine(:permission).should be_nil }
-  end
-
-  describe 'enable_helpers' do
-    before do
-      subject.enable_helpers :rest
-    end
-    specify { ::ApplicationController.instance_methods.should include(:link_to_new) }
-  end
-
-  describe 'localhosts' do
-    specify { subject.localhosts.registered.should include('localhost') }
-  end
-
-  describe 'orms' do
-    specify { subject.orms.registered.should be_empty }
-
-    describe 'register' do    
-      before do
-        subject.orms.register :mongoid
-      end
-      specify { subject.orms.registered.should include(:mongoid) }
-    end
-
-    describe '<<' do    
-      before do
-        subject.orms << :mongo_mapper
-      end
-      specify { subject.orms.registered.should include(:mongo_mapper) }
-    end
-  end
-  
-  describe "engines DSL" do
-    before(:all) {
-      CanTango.configure do |config|
-        CanTango.config.engines.each do |engine|
-          engine.set :off
-        end
-     end
-    }
-
-    describe 'engine(name)' do
-      CanTango.config.engines.registered_names.each do |name|
-        specify { subject.engine(name).off?.should be_true}
-      end
-    end
-
-    describe 'each' do
-      CanTango.config.engines.each do |engine|
-        specify { engine.on?.should be_false}
-        specify { engine.off?.should be_true}
-      end
-    end
-  end
-  
-  describe 'clear!' do
-    before do
-      subject.roles.exclude :user
-      subject.role_groups.exclude :admins
-
-      subject.clear!
-    end
-
-    specify { subject.roles.excluded.should be_empty }
-    specify { subject.role_groups.excluded.should be_empty }
-  end
-end