cohabit 0.0.1 → 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4ee059cff9113f9b438d138c88d31a229b7732b9
+  data.tar.gz: ade1a69aca01dc0f1c82ace515771a459053f9d1
+SHA512:
+  metadata.gz: ee9b05964894b01bd68cece139960de8234a73c3fbc673c4bb0a9ca0cee8add5c348135f804b846ed37aff1bc7c5671957e0369d36d7b0a7994a5cacecb81658
+  data.tar.gz: f83f0b91cc407b873384b396153720d48131586359949f49205c42c7a8ca231f9b4f1ead6203241658835eb412bdf32b10dca16b172ccf8296f7c64cdc72d20a

data/README.md

@@ -2,7 +2,9 @@
 
 Cohabit adds comprehensive scoped multi-tenancy functionality to any application, simply set your options up in `config/cohabit.rb` using the DSL (inspired by capistrano).
 
-It adds:
+This gem isn't really recommended for doing simple application wide scoping, for that I'd recommend https://github.com/wireframe/multitenant. Cohabit builds on what `multitenant` provides and allows you to define your own scoping strategies with the DSL for where more complexity is needed.
+
+It provides (or it will):
 
 - Model scoping (duh)
 - Custom scoping strategies
@@ -11,15 +13,6 @@ It adds:
 - Rake task for importing single-tenanted databases into a multi-tenant one
 - Rake task for generating multi-tenanted scoped schema
 
-## Todo
-
-Still a WIP. Need to:
-
-- Develop snippets to be included in strategies, i.e. scope_validations snippet (and remove that setting)
-- Should snippets just be nested strategies? wah, probably.
-- Work out how to integrate the url helper scopes as an option
-- Write the rake tasks
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -36,7 +29,137 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+In its simplest form, using the basic scope (typical `belongs_to` assiciation scope):
+    
+    # must have this line to use the included scopes
+    require 'basic'
+    scope [:foo, :bar], :basic
+
+By default it assumes your tenant model is called tenant, if you wish to change this you can set it globally:
+
+    set :association, :organisation
+    scope [:foo, :bar], :basic
+
+Or per scope with options:
+
+    scope [:foo, :bar], :basic, association: :organisation
+
+Or you can specify options and other configuration settings in block form:
+
+    scope [:foo, :bar] do
+      use_strategy: :basic
+      set :association, :organisation
+    end
+
+In your application, depending on how you determine the current tenant, you need to set `Cohabit.current_tenant`. If you're using subdomains, I would recommend writing some simple Rack middleware something like:
+
+    class TenantSetup
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @request = Rack::Request.new(env)
+        Cohabit.current_tenant = Tenant.find_by_subdomain!(get_subdomain)
+        @app.call(env)
+      end
+
+      private
+        def get_subdomain
+          # Check request host isn't an IP.
+          host = @request.host
+          return nil unless !(host.nil? || /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(host))
+          subdomain = host.split('.')[0..-3].first
+          return subdomain unless subdomain == "www"
+          return host.split('.')[0..-3][1]
+        end
+    end
+
+Alternatively, write a `before_filter` in the `ApplicationController`.
+
+### Strategies
+
+This part is a WIP, but you can define your own strategies to be used. The following is the :basic strategy that comes by default:
+
+    strategy :basic do
+      # simply gets evaluated in the models..
+      model_eval do |_scope|
+        # _scope var references the scope that uses the strategy,
+        # so to access settings, like :association, use
+        # _scope.settings[:association]. current_tenant is defined
+        # as Cohabit.current_tenant.
+
+        # add relationship
+        belongs_to _scope.settings[:association]
+
+        # get foreign key
+        reflection = reflect_on_association _scope.settings[:association]
+
+        # scope insertions
+        before_create Proc.new {|m|
+          return unless Cohabit.current_tenant
+          m.send "#{_scope.settings[:association]}=".to_sym, Cohabit.current_tenant
+        }
+
+        # scope selects
+        default_scope lambda {
+          where(reflection.foreign_key => Cohabit.current_tenant) if Cohabit.current_tenant
+        }
+      end
+    end
+
+You can define additional global vars in the Cohabit namespace, in your strategies, e.g.:
+
+    strategy :test do
+      set :globals, [:current_view, :current_scope]
+      # ...
+    end
+
+    # application_controller.rb
+    before_filter :set_scope
+    def set_scope
+      Cohabit.current_scope = Cohabit.current_tenant.managed_clients
+    end
+
+You can also nest strategies to DRY up your code a bit.
+
+    strategy :basic_tweaked do
+      include_strategy :basic
+      model_eval do |_scope|
+        # ...
+      end
+    end
+
+### Settings
+
+Once I've implemented it, you'll be able to scope URL helpers, so for example if your tenant features in your URL like so:
+
+    # routes file
+    # ...
+    resources :tenants do
+      resources :posts
+      resources :foo
+      resources :bar
+    end
+    # ...
+
+Giving you the paths `/tenant/1/posts/1` .. etc. You will be able to still call `posts_path(@post)`, and when the setting is enabled it will expand that internally to `tenants_posts_path(@post.tenant, @post)`.
+
+### Rake tasks
+
+There are two rake tasks in the pipeline to make life a bit easier for anyone converting from multi-database architecture to a multi-tenant, single-database architecture:
+
+1. Migrate DB or create new DB schema based on the scopes in a cohabit configuration file
+2. Import a number of single-tenanted databases into the multi-tenanted equivalent
+
+## Todo
+
+Still a WIP. Need to:
+
+- Work out how to integrate the url helper scopes as an option
+- Write the rake tasks
+- Add custom `cohabit_unscoped` (or similar) class method to models which removes all Cohabit `default_scope`s, `before_create`s, validation scopes, etc for that chain. (Possible? hmf)
+- Add a `conditions` option to `include_strategy`, like that of Rails routes perhaps
 
 ## Contributing
 

data/lib/cohabit.rb

@@ -2,34 +2,30 @@ require 'cohabit/errors'
 require 'cohabit/configuration'
 require 'cohabit/strategy'
 require 'cohabit/scope'
+require 'cohabit/route_helper_scope'
 
 module Cohabit
+  @data = {}
   class << self
     attr_accessor :current_tenant
-  end
 
-  module ActiveRecordExtensions
-    def _apply_cohabit_scope(_scope)
-      proc = _scope.strategy.model_code
-      instance_exec(_scope, &proc) if proc
+    def add_global(name)
+      singleton_class.send(:define_method, name) { @data[name] }
+      singleton_class.send(:define_method, "#{name}=") { |val| @data[name] = val }
     end
   end
 end
 
-ActiveRecord::Base.extend Cohabit::ActiveRecordExtensions
-
-if defined? ::Rails::Railtie
+if defined?(Rails) && Rails::VERSION::MAJOR.to_i >= 3
   module Cohabit
     class Railtie < Rails::Railtie
-      initializer "cohabit.configure" do |app|
-        config = Cohabit::Configuration.new
-        config.load(file: File.join(Rails.root, "config/cohabit.rb"))
-        config.apply_scopes!
+      initializer "cohabit.initialize_scopes" do
+        ActiveSupport.on_load :after_initialize do
+          config = Cohabit::Configuration.new
+          config.load(file: File.join(Rails.root, "config/cohabit.rb"))
+          config.apply_all!
+        end
       end
     end
   end
-else
-  config = Cohabit::Configuration.new
-  config.load(file: File.join(Rails.root, "config/cohabit.rb"))
-  config.apply_scopes!
 end

data/lib/cohabit/configuration.rb

@@ -2,7 +2,9 @@ require "cohabit/version"
 require "cohabit/configuration/settings"
 require "cohabit/configuration/strategies"
 require "cohabit/configuration/scopes"
+require "cohabit/configuration/route_helper_scopes"
 require "active_record"
+require "active_support/inflector"
 
 module Cohabit
   class Configuration
@@ -10,7 +12,7 @@ module Cohabit
     attr_reader :load_paths
 
     def initialize(config_file = nil)
-      @load_paths = [".", File.expand_path(File.join(File.dirname(__FILE__), "strategies"))]
+      @load_paths = [Rails.root.join("lib"), Rails.root.join("config"), ".", File.expand_path(File.join(File.dirname(__FILE__), "strategies"))]
     end
 
     def load(*args, &block)
@@ -40,7 +42,16 @@ module Cohabit
       end
     end
 
-    include Settings, Strategies, Scopes
+    def apply_all!
+      self.class.ancestors.take_while{|a| a != self.class.superclass}
+      .reject{|a| a == self.class}
+      .each do |a|
+        method = "apply_#{a.name.demodulize.underscore}!"
+        self.send(method, self) if self.respond_to?(method)
+      end
+    end
+
+    include Settings, Strategies, Scopes, RouteHelperScopes
 
   end
 end

data/lib/cohabit/configuration/route_helper_scopes.rb

@@ -0,0 +1,18 @@
+module Cohabit
+  class Configuration
+    module RouteHelperScopes
+
+      attr_accessor :route_scopes
+
+      def scope_route_helpers(*args)
+        generate_settings_hash!(args)
+        (@route_scopes ||= []) << RouteHelperScope.new(*args)
+      end
+
+      def apply_route_helper_scopes!(context = self)
+        @route_scopes.each{|rs| rs.apply!(context)}
+      end
+
+    end
+  end
+end

data/lib/cohabit/configuration/scopes.rb

@@ -16,13 +16,13 @@ module Cohabit
       attr_reader :scopes
 
       def scope(*args, &block)
-        args[1] &&= find_strategy_by_name(args[1])
+        generate_settings_hash!(args)
         scope = Scope.new(*args, &block)
         add_scope(scope)
       end
 
-      def apply_scopes!
-        @scopes.each{ |s| s.apply! }
+      def apply_scopes!(context = self)
+        @scopes.each{ |s| s.apply!(context) }
       end
 
       private

data/lib/cohabit/configuration/settings.rb

@@ -2,12 +2,13 @@ module Cohabit
   class Configuration
     module Settings
 
-      DEFULT_SETTINGZ = {
-        scope_validations: false,
-        scope_url_helpers: false,
-        association: :tenant
+      DEFAULT_SETTINGS = {
+        association: :tenant,
+        association_as: :tenant
       }
 
+      CUSTOM_HANDLERS = [:globals]
+
       def self.included(base)
         base.send :alias_method, :initialize_without_settings, :initialize
         base.send :alias_method, :initialize, :initialize_with_settings
@@ -17,12 +18,12 @@ module Cohabit
       attr_reader :settings
 
       def initialize_with_settings(*args, &block)
-        @settings = DEFULT_SETTINGZ.dup
+        @settings = DEFAULT_SETTINGS.dup
         initialize_without_settings(*args, &block)
       end
 
       def merge_settings!(settings)
-        settings.delete_if{ |s| !DEFULT_SETTINGZ.include?(s) }
+        settings.delete_if{ |s| !DEFAULT_SETTINGS.include?(s) }
         @settings.merge!(settings)
       end
 
@@ -35,10 +36,17 @@ module Cohabit
       end
 
       def set(setting, value)
-        if !DEFULT_SETTINGZ.include?(setting.to_sym)
-          raise ArgumentError, "what the fuck are you doing.. that's not a setting"
+        setting = setting.to_sym
+        if CUSTOM_HANDLERS.include?(setting)
+          send("set_#{setting}", value) and return
+        end
+        @settings[setting] = value
+      end
+
+      def set_globals(value)
+        [value].flatten.each do |v|
+          Cohabit.add_global(v) unless Cohabit.respond_to?(v)
         end
-        @settings[setting.to_sym] = value
       end
 
     end

data/lib/cohabit/configuration/strategies.rb

@@ -29,7 +29,7 @@ module Cohabit
 
       private
         def add_strategy(strategy)
-          raise StrategyNameExistsError if named_strategy_exists?(strategy.name)
+          raise StrategyNameExistsError, strategy.name if named_strategy_exists?(strategy.name)
           strategies << strategy
         end
 

data/lib/cohabit/errors.rb

@@ -4,6 +4,7 @@ module Cohabit
   
   StrategyNameExistsError = Class.new(Cohabit::Error)
   StrategyNotFoundError   = Class.new(Cohabit::Error)
+  StrategyNestingError    = Class.new(Cohabit::Error)
   InvalidScopeError       = Class.new(Cohabit::Error)
 
 end

data/lib/cohabit/route_helper_scope.rb

@@ -0,0 +1,65 @@
+module Cohabit
+  class RouteHelperScope
+
+    def initialize(*args)
+      merge_settings!(args.last) if args.last.is_a?(Hash)
+    end
+
+    include Configuration::Settings
+
+    def apply!(context)
+      named_routes = get_route_helpers
+
+      route_helpers = Module.new
+      route_helpers.module_exec(named_routes, @settings[:association], &route_override_proc)
+      Cohabit.const_set("RouteHelpers", route_helpers)
+      ActionView::Base.send :include, Cohabit::RouteHelpers
+    end
+
+    private
+      def get_route_helpers
+        named_routes_arr = Rails.application.routes.named_routes
+          .find_all{|rn, _| rn =~ /#{Regexp.escape(@settings[:association_as])}_/}
+          .group_by do |_, r|
+            name = r.path.names[r.path.names.index("#{@settings[:association_as]}_id")+1]
+            if name =~ /_id/
+              name.gsub("_id", "")
+            else
+              r.defaults[:controller].classify.downcase
+            end
+          end
+          .reject{|k, _| k.nil?}
+          .map{|g, rs| [g, Hash[rs.map{|rn, r| [rn.to_s.gsub("#{@settings[:association_as]}_", "").to_sym, rn]}]]}
+        # e.g. { student: { :school_student => :student, :school_edit_student => :edit_student } }
+        return Hash[named_routes_arr]
+      end
+
+      def route_override_proc
+        Proc.new do |named_routes, assoc|
+          named_routes.each do |mr, rs|
+            rs.each do |r, orig_r|
+              module_eval <<-EOT, __FILE__, __LINE__ + 1
+                def #{r}_path(*args)
+                  do_dat_thang!("path", "#{assoc}", "#{mr}", "#{orig_r}", *args) || super
+                end
+                def #{r}_url(*args)
+                  do_dat_thang!("url", "#{assoc}", "#{mr}", "#{orig_r}", *args) || super
+                end
+              EOT
+            end
+          end
+
+          def do_dat_thang!(type, assoc, main_resource, orig_route, obj, *args)
+            if obj.is_a?(Integer)
+              model = main_resource.classify.constantize
+              obj = model.find(obj)
+            end
+            if Cohabit.current_tenant.is_cluster? && obj.respond_to?(assoc)
+              send("#{orig_route}_#{type}", obj.send(assoc), obj, *args)
+            end
+          end
+        end
+      end
+
+  end
+end

data/lib/cohabit/scope.rb

@@ -10,7 +10,6 @@ module Cohabit
       apply_to(args[0])
       use_strategy(args[1])
       instance_eval(&block) unless block.nil?
-      merge_settings!(@strategy.settings)
       unless valid?
         raise InvalidScopeError, "provide valid model(s) and strategy"
       end
@@ -22,7 +21,7 @@ module Cohabit
 
     def use_strategy(strategy)
       unless strategy.nil?
-        @strategy = strategy
+        @strategy_name = strategy
       end
     end
 
@@ -30,17 +29,22 @@ module Cohabit
       @models = parse_models(models)
     end
 
-    def apply!
-      # apply yourself, that's what my teachers always said.
+    def apply!(context)
+      # apply yourself! that's what my teachers always said.
+      strategy_stack = get_strategies(@strategy_name, context)
+      main_strategy = context.find_strategy_by_name(@strategy_name)
+      merge_settings!(main_strategy.settings)
       @models.each do |model|
-        model._apply_cohabit_scope(self)
+        strategy_stack.each do |strategy|
+          model.instance_exec(self, &strategy.model_code)
+        end
       end
     end
 
     private
       def valid?
         return false if @models.empty?
-        return false if @strategy.nil?
+        return false if @strategy_name.nil?
         @models.each do |model|
           return false if !ActiveRecord::Base.descendants.include?(model)
         end
@@ -53,5 +57,20 @@ module Cohabit
         end
       end
 
+      def get_strategies(strategy_name, context, strategy_stack = [])
+        strategy = context.find_strategy_by_name(strategy_name)
+        strategy.strategies.each do |s|
+          if s == strategy.name
+            if strategy_stack.include?(strategy)
+              raise StrategyNestingError, "strategies can't be nested twice in the same stack"
+            end
+            strategy_stack << strategy
+          else
+            strategy_stack = get_strategies(s, context, strategy_stack)
+          end
+        end
+        strategy_stack
+      end
+
   end
 end

data/lib/cohabit/strategies/basic.rb

@@ -1,8 +1,11 @@
 strategy :basic do
   model_eval do |_scope|
+    # _scope var references the scope that uses the strategy,
+    # so to access settings, like :association, use
+    # _scope.settings[:association]. current_tenant is defined
+    # as Cohabit.current_tenant.
     belongs_to _scope.settings[:association]
     reflection = reflect_on_association _scope.settings[:association]
-    scope_validators(reflection.foreign_key) if _scope.settings[:scope_validations]
     before_create Proc.new {|m|
       return unless Cohabit.current_tenant
       m.send "#{_scope.settings[:association]}=".to_sym, Cohabit.current_tenant

data/lib/cohabit/strategies/defaults.rb

@@ -1,2 +1,3 @@
 require 'basic'
-require 'multi'
+require 'multi'
+require 'scope_validators'

data/lib/cohabit/strategies/multi.rb

@@ -1,13 +1,16 @@
-# strategy :multi do
-#   model_eval do
-#     reflection = reflect_on_association _scope.settings[:association]
-#     scope_validators(reflection.foreign_key) if _scope.settings[:scope_validations]
-#     before_create Proc.new {|m|
-#       return unless _scope.current_school
-#       m.send "#{_scope.settings[:association]}=".to_sym, _scope.current_school
-#     }
-#     default_scope lambda {
-#       where(reflection.foreign_key => _scope.current_scope) if _scope.current_scope
-#     }
-#   end
-# end
+strategy :multi do
+  set :globals, :current_scope
+  model_eval do |_scope|
+    belongs_to _scope.settings[:association]
+    reflection = reflect_on_association _scope.settings[:association]
+    # insertions are scoped to current_tenant
+    before_create Proc.new {|m|
+      return unless Cohabit.current_tenant
+      m.send "#{association}=".to_sym, Cohabit.current_tenant
+    }
+    # selects are scoped to multiple clients (stored in current_scope)
+    default_scope lambda {
+      where(reflection.foreign_key => Cohabit.current_scope) if Cohabit.current_scope
+    }
+  end
+end

data/lib/cohabit/strategies/scope_validators.rb

@@ -0,0 +1,20 @@
+strategy :scope_validators do
+  model_eval do |_scope|
+    reflection = reflect_on_association _scope.settings[:association]
+    foreign_key = reflection.foreign_key
+    _validators.each do |attribute, validations|
+      validations.reject!{|v| v.kind == :uniqueness}
+    end
+    new_callback_chain = self._validate_callbacks.reject do |callback|
+      callback.raw_filter.is_a?(ActiveRecord::Validations::UniquenessValidator)
+    end
+    deleted = self._validate_callbacks - new_callback_chain
+    (self._validate_callbacks.clear << new_callback_chain).flatten!
+    deleted.each do |c|
+      v = c.raw_filter
+      v.attributes.each do |a|
+        validates_uniqueness_of *v.attributes, v.options.merge(scope: foreign_key)
+      end
+    end
+  end
+end

data/lib/cohabit/strategy.rb

@@ -5,6 +5,7 @@ module Cohabit
 
     def initialize(*args, &block)
       raise ArgumentError, "you must supply a name" if args.empty?
+      @strategies = []
       @name = args.shift.to_sym
       @settings = args.last.is_a?(Hash) ? args.last : {}
       instance_eval(&block) unless block.nil?
@@ -12,10 +13,21 @@ module Cohabit
 
     include Configuration::Settings
 
-    attr_reader :name, :model_code
+    attr_reader :name, :model_code, :strategies
 
     def model_eval(&block)
       @model_code = block
+      @strategies << @name
+    end
+
+    def include_strategy(name, options = {})
+      name = name.to_sym
+      raise ArgumentError if name.nil?
+      if @strategies.include?(name)
+        raise Argumenterror, "can't nest the same strategy twice
+        or use two model_eval blocks in the same strategy"
+      end
+      @strategies << name
     end
 
   end

data/lib/cohabit/version.rb

@@ -1,3 +1,3 @@
 module Cohabit
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/scopes_test.rb

@@ -31,11 +31,20 @@ class ScopesTest < Test::Unit::TestCase
       scope :ybur, :basic, association: :client
     end
     assert_equal(:client, @c.scopes.first.settings[:association])
-  end 
+  end
+
+  def test_settings_for_scope_globally
+    @c.load do
+      require 'basic'
+      set :association, :client
+      scope :ybur, :basic
+    end
+    assert_equal(:client, @c.scopes.first.settings[:association])
+  end
 
   def test_apply_scope_to_model
-    c = Client.create(name: "fubar")
-    Cohabit.current_tenant = c
+    client = Client.create(name: "fubar")
+    Cohabit.current_tenant = client
     @c.load do
       require 'basic'
       scope :ybur, :basic
@@ -45,8 +54,8 @@ class ScopesTest < Test::Unit::TestCase
   end
 
   def test_setting_association_name
-    c = Client.create(name: "fubar")
-    Cohabit.current_tenant = c
+    client = Client.create(name: "fubar")
+    Cohabit.current_tenant = client
     @c.load do
       require 'basic'
       scope :ybur, :basic, association: :client
@@ -55,4 +64,57 @@ class ScopesTest < Test::Unit::TestCase
     assert_match(/client_id/, Ybur.scoped.to_sql)
   end
 
+  def test_nested_strategy_scope_basic
+    client = Client.create(name: "fubar")
+    Cohabit.current_tenant = client
+    # should run like normal basic strategy
+    @c.load do
+      require 'basic'
+      strategy :frankel, { association: :client } do
+        include_strategy :basic
+      end
+      scope :ybur, :frankel
+    end
+    @c.apply_scopes!
+    assert_not_equal(Ybur.unscoped.to_sql, Ybur.scoped.to_sql)
+  end
+
+  def test_nested_strategy_scope_override
+    client = Client.create(name: "fubar")
+    Cohabit.current_tenant = client
+    # should remove basic strategy's default scope, as it
+    # is evaluated after it in the main strategy
+    @c.load do
+      require 'basic'
+      strategy :frankel, { association: :client } do
+        include_strategy :basic
+        model_eval do |_scope|
+          default_scopes.clear
+        end
+      end
+      scope :ybur, :frankel
+    end
+    @c.apply_scopes!
+    assert_equal(Ybur.unscoped.to_sql, Ybur.scoped.to_sql)
+  end
+
+  def test_evaluation_order_in_nested_strategies
+    client = Client.create(name: "fubar")
+    Cohabit.current_tenant = client
+    # should remove basic strategy's default scope, as it
+    # is evaluated after it in the main strategy
+    @c.load do
+      require 'basic'
+      strategy :frankel, { association: :client } do
+        model_eval do |_scope|
+          default_scopes.clear
+        end
+        include_strategy :basic
+      end
+      scope :ybur, :frankel
+    end
+    @c.apply_scopes!
+    assert_not_equal(Ybur.unscoped.to_sql, Ybur.scoped.to_sql)
+  end
+
 end

data/test/settings_test.rb

@@ -4,24 +4,17 @@ class SettingsTest < Test::Unit::TestCase
     @c = Cohabit::Configuration.new
   end
  
-  def test_set_real_setting
-    assert_not_equal(@c.settings[:scope_validations], true)
+  def test_set_setting
     @c.set :scope_validations, true
     assert_equal(true, @c.settings[:scope_validations])
   end
 
-  def test_set_nonexitant_setting
-    assert_raise(ArgumentError) do
-      @c.set :wtf_not_a_real_setting, "dis is a value, innit"
-    end
-  end
-
   def test_set_setting_with_config
-    assert_equal(false, @c.settings[:scope_validations])
+    assert_equal(:tenant, @c.settings[:association])
     @c.load do
-      set :scope_validations, true
+      set :association, :client
     end
-    assert_equal(true, @c.settings[:scope_validations])
+    assert_equal(:client, @c.settings[:association])
   end
 
 end

data/test/strategies_test.rb

@@ -37,7 +37,6 @@ class StrategiesTest < Test::Unit::TestCase
     # strategy block defaults > strategy arg defaults
 
     # should take on strategy default settings when passed in
-    setup
     @c.load do
       strategy :frankel, { scope_validations: true }
     end
@@ -54,4 +53,14 @@ class StrategiesTest < Test::Unit::TestCase
     assert_equal(true, @c.strategies.first.settings[:scope_validations])
   end
 
+  def test_nested_strategy
+    @c.load do
+      strategy :jim
+      strategy :frankel, { association: :client } do
+        include_strategy :jim
+      end
+    end
+    assert_equal([:jim], @c.find_strategy_by_name(:frankel).strategies)
+  end 
+
 end

data/test/test_helper.rb

@@ -3,9 +3,9 @@ require "test/unit"
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
+require "cohabit"
 require "active_record"
 require "models"
-require "cohabit"
 
 def load_schema
   config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))

metadata

@@ -1,52 +1,46 @@
 --- !ruby/object:Gem::Specification
 name: cohabit
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 0.0.2
 platform: ruby
 authors:
 - Mike Campbell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-02 00:00:00.000000000 Z
+date: 2014-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   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'
 - !ruby/object:Gem::Dependency
   name: activesupport
   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'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -54,7 +48,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -62,17 +55,15 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Handle application scoping for multi-tenant applications with table scopes.
@@ -90,15 +81,17 @@ files:
 - cohabit.gemspec
 - lib/cohabit.rb
 - lib/cohabit/configuration.rb
+- lib/cohabit/configuration/route_helper_scopes.rb
 - lib/cohabit/configuration/scopes.rb
 - lib/cohabit/configuration/settings.rb
 - lib/cohabit/configuration/strategies.rb
 - lib/cohabit/errors.rb
+- lib/cohabit/route_helper_scope.rb
 - lib/cohabit/scope.rb
-- lib/cohabit/snippets.rb
 - lib/cohabit/strategies/basic.rb
 - lib/cohabit/strategies/defaults.rb
 - lib/cohabit/strategies/multi.rb
+- lib/cohabit/strategies/scope_validators.rb
 - lib/cohabit/strategy.rb
 - lib/cohabit/version.rb
 - test/all_tests.rb
@@ -113,27 +106,26 @@ files:
 homepage: http://github.com/mikecmpbll/cohabit
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.0.6
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Scope multi-tenant applications.
 test_files:
 - test/all_tests.rb

data/lib/cohabit/snippets.rb

@@ -1,4 +0,0 @@
-module Cohabit
-  class Snippets
-  end
-end