tenancy 0.2.0 → 1.0.0

data/lib/tenancy/resource_scope.rb

@@ -3,65 +3,28 @@ module Tenancy
     extend ActiveSupport::Concern
 
     module ClassMethods
-      attr_reader :scope_fields
-
-      def scope_fields
-        @scope_fields ||= []
-      end
 
       def scope_to(*resources)
-        options = resources.extract_options!.dup
-        raise ArgumentError, 'options should be blank if there are multiple resources' if resources.count > 1 and options.present?
-
-        resources.each do |resource|
-          resource         = resource.to_sym
-          resource_class_name ||= (options[:class_name].to_s.presence || resource.to_s).classify
-          resource_class   = resource_class_name.constantize
-
-          # validates and belongs_to
-          validates         resource, presence: true
-          belongs_to        resource, options
-
-          # default_scope
-          resource_foreign_key = reflect_on_association(resource).foreign_key
-          scope_fields     << resource_foreign_key
-          default_scope     { where(:"#{resource_foreign_key}" => resource_class.current_id) if resource_class.current_id }
-
-          # override to return current resource instance
-          # so that it doesn't touch db
-          define_method(resource) do |reload=false|
-            return super(reload) if reload
-            return resource_class.current if send(resource_foreign_key) == resource_class.current_id
-            super(reload)
-          end
-        end
+        tenancy_scoping.scope_to(resources)
       end
 
-      # inspired by: https://github.com/goncalossilva/acts_as_paranoid/blob/rails3.2/lib/acts_as_paranoid/core.rb#L76
-      def without_scope(*resources)
-        scope = where(nil).with_default_scope
-        resources.each do |resource|
-          resource   = resource.to_sym
-          reflection = reflect_on_association(resource)
-          next       if reflection.nil?
-
-          resource_scope_sql = where(nil).table[reflection.foreign_key].eq(reflection.klass.current_id).to_sql
-
-          scope.where_values.delete_if { |query| query.to_sql == resource_scope_sql }
-        end
-
-        scope
+      def tenant_scope(*resources)
+        tenancy_scoping.tenant_scope(resources)
       end
 
       def validates_uniqueness_in_scope(fields, args={})
-        if args[:scope]
-          args[:scope] = Array.wrap(args[:scope]) << scope_fields
-        else
-          args[:scope] = scope_fields
-        end
-
-        validates_uniqueness_of(fields, args)
+        tenancy_scoping.validates_uniqueness_in_scope(fields, args)
       end
+
+      private
+
+        def tenancy_scoping
+          @tenancy_scoping ||= if defined?(::ActiveRecord) && ancestors.include?(::ActiveRecord::Base)
+            Scoping::ActiveRecord.new(self)
+          elsif defined?(Mongoid) && ancestors.include?(Mongoid::Document)
+            Scoping::Mongoid.new(self)
+          end
+        end
     end
   end
 end

data/lib/tenancy/scoping.rb

@@ -0,0 +1,13 @@
+module Tenancy
+  class Scoping
+    autoload :ActiveRecord, "tenancy/scoping/active_record"
+    autoload :Mongoid,      "tenancy/scoping/mongoid"
+
+    attr_reader :klass, :tenants
+
+    def initialize(klass)
+      @klass   = klass
+      @tenants = []
+    end
+  end
+end

data/lib/tenancy/scoping/active_record.rb

@@ -0,0 +1,52 @@
+module Tenancy
+  class Scoping::ActiveRecord < Scoping
+
+    def scope_to(tenant_names)
+      options = tenant_names.extract_options!.dup
+      raise ArgumentError, "options should be blank if there are multiple tenants" if tenant_names.count > 1 and options.present?
+
+      tenant_names.each do |tenant_name|
+        # validates and belongs_to
+        klass.validates   tenant_name, presence: true
+        klass.belongs_to  tenant_name, options
+
+        tenant            = Tenant.new(tenant_name, options[:class_name], klass)
+        self.tenants      << tenant
+
+        # default_scope
+        klass.send(:default_scope, lambda { klass.where(:"#{tenant.foreign_key}" => tenant.klass.current_id) if tenant.klass.current_id })
+
+        # override to return current tenant instance
+        # so that it doesn"t touch db
+        klass.send(:define_method, tenant_name, lambda { |reload=false|
+          return super(reload) if reload
+          return tenant.klass.current if send(tenant.foreign_key) == tenant.klass.current_id
+          super(reload)
+        })
+      end
+    end
+
+    def tenant_scope(tenant_names)
+      scope = klass.where(nil).with_default_scope
+      tenants.each do |tenant|
+        next if tenant_names.include?(tenant.name.to_sym)
+
+        tenant_scope_sql = klass.where(nil).table[tenant.foreign_key].eq(tenant.klass.current_id).to_sql
+        scope.where_values.delete_if { |query| query.to_sql == tenant_scope_sql }
+      end
+
+      scope
+    end
+
+    def validates_uniqueness_in_scope(fields, args={})
+      foreign_keys = tenants.map(&:foreign_key)
+      if args[:scope]
+        args[:scope] = Array.wrap(args[:scope]) << foreign_keys
+      else
+        args[:scope] = foreign_keys
+      end
+
+      klass.validates_uniqueness_of(fields, args)
+    end
+  end
+end

data/lib/tenancy/scoping/mongoid.rb

@@ -0,0 +1,79 @@
+module Tenancy
+  class Scoping::Mongoid < Scoping
+
+    def scope_to(tenant_names)
+      options = tenant_names.extract_options!.dup
+      raise ArgumentError, "options should be blank if there are multiple tenants" if tenant_names.count > 1 and options.present?
+
+      tenant_names.each do |tenant_name|
+        # validates and belongs_to
+        klass.validates         tenant_name, presence: true
+        klass.belongs_to        tenant_name, options
+
+        tenant                  = Tenant.new(tenant_name, options[:class_name], klass)
+        self.tenants            << tenant
+
+        # default_scope
+        klass.default_scope  lambda {
+          if tenant.klass.current_id
+            klass.where(:"#{tenant.foreign_key}" => tenant.klass.current_id)
+          else
+            klass.where(nil)
+          end
+        }
+
+        # override to return current tenant_name instance
+        # so that it doesn't touch db
+        klass.send(:define_method, :"#{tenant_name}_with_tenant", lambda { |reload=false|
+          return send(:"#{tenant_name}_without_tenant", reload) if reload
+          return tenant.klass.current if send(tenant.foreign_key) == tenant.klass.current_id
+          send(:"#{tenant_name}_without_tenant", reload)
+        })
+        klass.alias_method_chain :"#{tenant_name}", :tenant
+
+        # override getter for mongoid 3.1
+        if ::Mongoid::VERSION.start_with?("3.1.")
+          klass.send(:define_method, tenant.foreign_key, lambda {
+            value = super()
+            if value.nil? && new_record?
+              self[tenant.foreign_key] = tenant.klass.current_id
+            end
+            self[tenant.foreign_key]
+          })
+        end
+      end
+
+      # tenants variable is for lambda
+      tenants = self.tenants
+      klass.send(:define_method, :shard_key_selector, lambda {
+        selector = super()
+        tenants.each do |tenant|
+          selector[tenant.foreign_key.to_s] = send(tenant.foreign_key) if tenant.klass.current_id
+        end
+        selector
+      })
+    end
+
+    def tenant_scope(tenant_names)
+      scope = klass.where(nil)
+      tenants.each do |tenant|
+        next if tenant_names.include?(tenant.name.to_sym)
+
+        scope.selector.delete(tenant.foreign_key.to_s)
+      end
+
+      scope
+    end
+
+    def validates_uniqueness_in_scope(fields, args={})
+      foreign_keys = tenants.map(&:foreign_key)
+      if args[:scope]
+        args[:scope] = Array.wrap(args[:scope]) << foreign_keys
+      else
+        args[:scope] = foreign_keys
+      end
+
+      klass.validates_uniqueness_of(fields, args)
+    end
+  end
+end

data/lib/tenancy/tenant.rb

@@ -0,0 +1,13 @@
+module Tenancy
+  class Tenant
+    attr_accessor :name, :klass, :klass_name, :foreign_key
+
+    def initialize(name, klass_name, host_klass)
+      @name        = name.to_sym
+      @klass_name  = (klass_name.to_s.presence || name.to_s).classify
+      @klass       = @klass_name.constantize
+      @foreign_key = host_klass.reflect_on_association(@name).foreign_key.to_sym
+    end
+
+  end
+end

data/lib/tenancy/version.rb

@@ -1,3 +1,3 @@
 module Tenancy
-  VERSION = "0.2.0"
+  VERSION = "1.0.0"
 end

data/spec/lib/resource_spec.rb

@@ -1,57 +1,101 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe "Tenancy::Resource" do
-  before(:all) do
-    @camyp   = Portal.create(id: 1, domain_name: 'yp.com.kh')
-    @panpage = Portal.create(id: 2, domain_name: 'panpages.my')
-    @yoolk   = Portal.create(id: 3, domain_name: 'yoolk.com')
-  end
+if defined?(ActiveRecord)
+  describe "Tenancy::Resource" do
+    let(:camyp)   { Portal.create(id: 1, domain_name: "yp.com.kh") }
+    let(:panpage) { Portal.create(id: 2, domain_name: "panpages.my") }
+    let(:yoolk)   { Portal.create(id: 3, domain_name: "yoolk.com") }
 
-  after(:all) do
-    Portal.delete_all
-  end
+    it "set current with instance" do
+      Portal.current = camyp
 
-  before(:each) { RequestStore.store[:'Portal.current'] = nil }
+      Portal.current.should == camyp
+      RequestStore.store[:"Portal.current"].should == camyp
+    end
 
-  it "set current with instance" do
-    Portal.current = @camyp
+    it "set current with id" do
+      Portal.current = panpage.id
 
-    Portal.current.should == @camyp
-    RequestStore.store[:'Portal.current'].should == @camyp
-  end
+      Portal.current.should == panpage
+      RequestStore.store[:"Portal.current"].should == panpage
+    end
 
-  it "set current with id" do
-    Portal.current = @panpage.id
+    it "set current with nil" do
+      Portal.current = panpage
+      Portal.current = nil
 
-    Portal.current.should == @panpage
-    RequestStore.store[:'Portal.current'].should == @panpage
-  end
+      Portal.current.should == nil
+      RequestStore.store[:"Portal.current"].should == nil
+    end
 
-  it "set current with nil" do
-    Portal.current = @panpage
-    Portal.current = nil
+    it "#current_id" do
+      Portal.current = yoolk
 
-    Portal.current.should == nil
-    RequestStore.store[:'Portal.current'].should == nil
-  end
+      Portal.current_id.should == yoolk.id
+    end
 
-  it "#current_id" do
-    Portal.current = @yoolk
+    it "#with_scope with block" do
+      Portal.current.should == nil
 
-    Portal.current_id.should == @yoolk.id
+      Portal.with_tenant(yoolk) do
+        Portal.current.should == yoolk
+      end
+
+      Portal.current.should == nil
+    end
+
+    it "#with_scope without block" do
+      expect { Portal.with_tenant(yoolk) }.to raise_error(ArgumentError)
+    end
   end
+end
+
+if defined?(Mongoid)
+  describe "Tenancy::Resource" do
+    let(:camyp)   { Mongo::Portal.create(domain_name: "yp.com.kh") }
+    let(:panpage) { Mongo::Portal.create(domain_name: "panpages.my") }
+    let(:yoolk)   { Mongo::Portal.create(domain_name: "yoolk.com") }
 
-  it "#with with block" do
-    Portal.current.should == nil
+    it "set current with instance" do
+      Mongo::Portal.current = camyp
 
-    Portal.with(@yoolk) do
-      Portal.current.should == @yoolk
+      Mongo::Portal.current.should == camyp
+      RequestStore.store[:"Mongo::Portal.current"].should == camyp
     end
 
-    Portal.current.should == nil
-  end
+    it "set current with id" do
+      Mongo::Portal.current = panpage.id
+
+      Mongo::Portal.current.should == panpage
+      RequestStore.store[:"Mongo::Portal.current"].should == panpage
+    end
+
+    it "set current with nil" do
+      Mongo::Portal.current = panpage
+      Mongo::Portal.current = nil
+
+      Mongo::Portal.current.should == nil
+      RequestStore.store[:"Mongo::Portal.current"].should == nil
+    end
+
+    it "#current_id" do
+      Mongo::Portal.current = yoolk
 
-  it "#with without block" do
-    expect { Portal.with(@yoolk) }.to raise_error(ArgumentError)
+      Mongo::Portal.current_id.should == yoolk.id
+    end
+
+    it "#with_scope with block" do
+      Mongo::Portal.current.should == nil
+
+      Mongo::Portal.with_tenant(yoolk) do
+        Mongo::Portal.current.should == yoolk
+      end
+
+      Mongo::Portal.current.should == nil
+    end
+
+    it "#with_scope without block" do
+      expect { Mongo::Portal.with_tenant(yoolk) }.to raise_error(ArgumentError)
+    end
   end
 end

data/spec/lib/scoping/active_record_spec.rb

@@ -0,0 +1,135 @@
+require "spec_helper"
+
+if defined?(ActiveRecord)
+  describe "Tenancy::Scoping::ActiveRecord" do
+    let(:camyp)     { Portal.create(domain_name: "yp.com.kh") }
+    let(:panpages)  { Portal.create(domain_name: "panpages.com") }
+    let(:listing)   { Listing.create(name: "Listing 1", portal_id: camyp.id) }
+
+    describe Listing do
+      it { should belong_to(:portal) }
+
+      it { should validate_presence_of(:portal) }
+
+      it { should validate_uniqueness_of(:name).scoped_to(:portal_id).case_insensitive }
+
+      it "have default_scope with :portal_id field" do
+        Portal.current = camyp
+
+        expect(Listing.where(nil).to_sql).to eq(Listing.where(portal_id: Portal.current_id).to_sql)
+      end
+
+      it "doesn't have default_scope when it doesn't have current portal" do
+        Portal.current = nil
+
+        expect(Listing.where(nil).to_sql).not_to include(%{"listings"."portal_id" = #{Portal.current_id}})
+      end
+    end
+
+    describe Communication do
+      it { should belong_to(:portal) }
+
+      it { should validate_presence_of(:portal) }
+
+      it { should belong_to(:listing) }
+
+      it { should validate_presence_of(:listing) }
+
+      it { should validate_uniqueness_of(:value).scoped_to(:portal_id, :listing_id) }
+
+      it "have default_scope with :portal_id and :listing_id" do
+        Portal.current  = camyp
+        Listing.current = listing
+
+        Communication.where(nil).to_sql.should == Communication.where(portal_id: Portal.current_id, listing_id: Listing.current_id).to_sql
+      end
+
+      it "doesn't have default_scope when it doesn't have current portal and listing" do
+        Portal.current  = nil
+        Listing.current = nil
+
+        expect(Communication.where(nil).to_sql).not_to include(%{"communications"."portal_id" = #{Portal.current_id}})
+        expect(Communication.where(nil).to_sql).not_to include(%{"communications"."listing_id" = #{Listing.current_id}})
+      end
+    end
+
+    describe ExtraCommunication do
+      it { should belong_to(:portal) }
+
+      it { should belong_to(:listing) }
+
+      it "raise exception when passing two resources and options" do
+        expect { ExtraCommunication.scope_to(:portal, :listing, class_name: "Listing") }.to raise_error(ArgumentError)
+      end
+
+      it "uses the correct scope" do
+        listing2 = Listing.create(name: "Name 2", portal: camyp)
+
+        Portal.current = camyp
+        Listing.current = listing2
+
+        extra_communication = ExtraCommunication.new
+        expect(extra_communication.listing_id).to eq(listing2.id)
+        expect(extra_communication.portal_id).to eq(camyp.id)
+      end
+    end
+
+    describe "belongs_to method override" do
+      before(:each) { Portal.current = camyp }
+
+      it "reload belongs_to when passes true" do
+        listing.portal.domain_name = "abc.com"
+        expect(listing.portal(true).object_id).not_to eq(Portal.current.object_id)
+      end
+
+      it "doesn't reload belongs_to" do
+        listing.portal.domain_name = "abc.com"
+        expect(listing.portal.object_id).to eq(Portal.current.object_id)
+      end
+
+      it "returns different object" do
+        listing.portal_id = panpages.id
+        expect(listing.portal.object_id).not_to eq(Portal.current.object_id)
+      end
+
+      it "doesn't touch db" do
+        current_listing = listing
+
+        Portal.establish_connection(adapter: "sqlite3", database: "spec/invalid.sqlite3")
+        expect(current_listing.portal.object_id).to eq(Portal.current.object_id)
+
+        Portal.establish_connection(ActiveRecord::Base.connection_config)
+      end
+    end
+
+    describe "#tenant_scope" do
+      before(:each) { Portal.current = camyp }
+
+      it "scopes only :current_portal" do
+        Listing.current = listing
+
+        expect(Communication.tenant_scope(:portal).to_sql).not_to include(%{"communications"."listing_id" = #{Listing.current_id}})
+        expect(Communication.tenant_scope(:portal).to_sql).to eq(%{SELECT "communications".* FROM "communications"  WHERE "communications"."is_active" = 't' AND "communications"."portal_id" = #{Portal.current_id}})
+      end
+
+      it "scopes only :current_listing" do
+        Listing.current = listing
+
+        expect(Communication.tenant_scope(:listing).to_sql).not_to include(%{"communications"."portal_id" = #{Portal.current_id}})
+        expect(Communication.tenant_scope(:listing).to_sql).to eq(%{SELECT "communications".* FROM "communications"  WHERE "communications"."is_active" = 't' AND "communications"."listing_id" = #{Listing.current_id}})
+      end
+
+      it "scopes only :current_listing and :current_portal" do
+        Listing.current = listing
+
+        expect(Communication.tenant_scope(:listing, :portal).to_sql).to eq(Communication.where(nil).to_sql)
+      end
+
+      it "scopes nothing" do
+        Listing.current = listing
+
+        expect(Communication.tenant_scope(nil).to_sql).to eq(%{SELECT "communications".* FROM "communications"  WHERE "communications"."is_active" = 't'})
+      end
+    end
+  end
+end