acts_as_multi_tenant 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a7efff0258142b5081c4778a8626aceefd8d78cb
+  data.tar.gz: 6305edc6f12418e6ca9e02924c85efe276c1d18e
+SHA512:
+  metadata.gz: f847b489613a624ee807987c4b83c44215ebb9cad639a98f62477e4570f4636cf14997577a97121ba5491983179a0bb5780fa5108722b468713ab3e33b6c3be4
+  data.tar.gz: 7a7600f3c384445fc3c7e513bed0525bcd90778c46c7afefd2a3934c5b5187072d45076b348370f1b2210c7e0395f46ae31da5f0e00da9e19971c43b2a2d0ac7

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2017 Consolo Services Group, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,128 @@
+# acts_as_multi_tenant
+
+Keep multiple tenants in a single ActiveRecord database, and keep their data separate. Let's say the `Client` AR model represents your "tenants". Some Rack middleware will keep track of the "current" client in the request cycle, which will automatically filter *all ActiveRecord queries* by that client, and automatically associate new records to the client as well.
+
+There are 3 main components:
+
+* `MultiTenant::Middleware` Rack middleware to wrap the request with the current tenant
+* `acts_as_tenant` ActiveRecord macro to specify which model houses all those tenants
+* `belongs_to_tenant` Extention of the ActiveRecord `belongs_to` macro to specify that a model belongs to a tenant
+
+## MultiTenant::Middleware
+
+Add the middleware in **config.ru**, or wherever you add middleware.
+
+```ruby
+use MultiTenant::Middleware,
+  # (required) The tenant model we want to set "current" on.
+  # Can be the class String name, a Proc, the class itself, or the class + a scope.
+  model: -> { Client.active },
+
+  # (required) Fetch the identifier of the current tenant from a Rack::Request object
+  identifier: ->(req) { req.host.split(/\./)[0] },
+
+  # (optional) Array of tentants that don't exist in the database, but should be allowed through anyway.
+  # IMPORTANT For these, Tenant.current will be nil!
+  global_identifiers: %w(global),
+
+  # (optional) Array of Strings or Regexps for paths that don't require a tenant. Only applies 
+  # when the tenant isn't specified in the request - not when a given tenant can't be found.
+  global_paths: [
+    '/about',
+    %r{^/api/v\d+/login$},
+  ],
+
+  # (optional) Returns a Rack response when a tenant couldn't be found in the db, or when
+  # a tenant isn't given (and isn't in the `global_paths` list)
+  not_found: ->(x) {
+    body = {errors: ["'%s' is not a valid tenant!" % x]}.to_json
+    [400, {'Content-Type' => 'application/json', 'Content-Length' => body.size.to_s}, [body]]
+  }
+```
+
+## acts_as_tenant
+
+Let's say that your tenants are stored with the `Client` model, and the `code` column stores each client's unique lookup/identifier value.
+
+```ruby
+class Client < ActiveRecord::Base
+  acts_as_tenant using: :code
+end
+```
+
+## belongs_to_tenant
+
+Now tell your models that they belong to a tenant. You can use all the normal ActiveRecord `belongs_to` arguments, including the scope `Proc` and the options `Hash`.
+
+```ruby
+class Widget < ActiveRecord::Base
+  belongs_to_tenant :client
+end
+
+class Spline < ActiveRecord::Base
+  belongs_to_tenant :client
+end
+```
+
+## belongs_to_tenant_through
+
+Maybe you have a model that indirectly belongs to several tenants. For example, a User may have multiple Memberships, each of which belongs to a different Client.
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :memberships
+  belongs_to_tenant_through :memberships
+end
+
+class Membership < ActiveRecord::Base
+  belongs_to_tenant :client
+  belongs_to :user
+end
+```
+
+## proxies_to_tenant
+
+Let's say you need a layer of indirection between clients and their records, to allow multiple clients to all share their records. Let's call it a License: several clients can be signed onto a single license, and records are associated to the license itself. Therefore, all clients with that license will share a single pool of records.
+
+See the full documenation for MultiTenant::ProxiesToTenant for a list of compatible association configurations. But here's on example of a valid configuration:
+
+```ruby
+# The tenant model that's hooked up to the Rack middleware and holds the "current" tenant
+class Client < ActiveRecord::Base
+  belongs_to :license
+  acts_as_tenant
+end
+
+# The proxy model that's (potentially) associated with multiple tenants
+class License < ActiveRecord::Base
+  has_many :clients, inverse_of: :license
+  proxies_to_tenant :clients
+end
+
+# Widets will be associated to a License (instead of a Client), therefore they are automatically
+# shared with all Clients who use that License.
+class Widget < ActiveRecord::Base
+  belongs_to_tenant :license
+  has_many :clients, through: :license # not required - just for clarity
+end
+
+# Splines, on the other hand, still belong directly to individual Clients like normal.
+class Spline < ActiveRecord::Base
+  belongs_to_tenant :client
+end
+
+# This is how it works behind the scenes
+License.current == Client.current.license
+```
+
+## Testing
+
+    bundle install
+    bundle exec rake test
+
+By default, bundler will install the latest (supported) version of ActiveRecord. To specify a version to test against, run:
+
+    AR=4.2 bundle update activerecord
+    bundle exec rake test
+
+Look inside `Gemfile` to see all testable versions.

data/lib/acts_as_multi_tenant.rb

@@ -0,0 +1,7 @@
+require 'active_record'
+require_relative 'multi_tenant/version'
+require_relative 'multi_tenant/acts_as_tenant'
+require_relative 'multi_tenant/proxies_to_tenant'
+require_relative 'multi_tenant/belongs_to_tenant'
+require_relative 'multi_tenant/belongs_to_tenant_through'
+require_relative 'multi_tenant/middleware'

data/lib/multi_tenant/acts_as_tenant.rb

@@ -0,0 +1,114 @@
+#
+# The main acts_as_multi_tenant module.
+#
+module MultiTenant
+  #
+  # Contains helpers to turn an ActiveRecord model into the tenant source.
+  #
+  module ActsAsTenant
+    #
+    # Use this ActiveRecord model as the tenant source.
+    #
+    # @param using [String] (optional) column that contains the unique lookup identifier. Defaults to :code.
+    #
+    def acts_as_tenant(using: :code)
+      cattr_accessor :tenant_identifier, :tenant_thread_var
+      self.tenant_identifier = using
+      self.tenant_thread_var = "current_tenant_#{object_id}".freeze # allows there to be multiple tenant classes
+      self.extend MultiTenant::ActsAsTenant::ClassMethods
+    end
+
+    #
+    # Returns true if this model is being used as a tenant.
+    #
+    # @return [Boolean]
+    #
+    def acts_as_tenant?
+      respond_to? :tenant_identifier
+    end
+
+    #
+    # Class methods applied to the tenant model.
+    #
+    #   class Client < ActiveRecord::Base
+    #     acts_as_tenant using: :code
+    #   end
+    #
+    #   Client.current
+    #   => # the current client set by the middleware, or nil
+    #
+    #   # Manually set the current client, where 'acme' is in the 'code' col in the db
+    #   Client.current = 'acme'
+    #
+    #   # Manually set the current client to an AR record
+    #   Client.current 
+    #
+    module ClassMethods
+      #
+      # Return the current tenant record, if any. Thread-safe.
+      #
+      # @return the current tenant record
+      #
+      def current
+        Thread.current.thread_variable_get tenant_thread_var
+      end
+
+      #
+      # Set the current tenant record. You may either pass an ActiveRecord Client record, OR the value
+      # of the `:using` option you passed to `acts_as_tenant`. Thread-safe.
+      #
+      # @param record_or_identifier the record or the identifier in the 'tenant_identifier' column.
+      #
+      def current=(record_or_identifier)
+        obj = if record_or_identifier.is_a? self
+                record_or_identifier
+              elsif record_or_identifier
+                where({tenant_identifier => record_or_identifier}).first
+              else
+                nil
+              end
+        Thread.current.thread_variable_set tenant_thread_var, obj
+      end
+
+      #
+      # Loops through each tenant, sets it as current, and yields to any given block.
+      # At the end, current is always set back to what it was originally.
+      #
+      def with_each_tenant
+        old_current = self.current
+        all.each do |tenant|
+          self.current = tenant
+          yield if block_given?
+        end
+      ensure
+        self.current = old_current
+      end
+
+      #
+      # Sets the given tenant as the current one and yields to a given block.
+      # At the end, current is always set back to what it was originally.
+      #
+      def with_tenant(record_or_identifier)
+        old_current = self.current
+        self.current = record_or_identifier
+        yield if block_given?
+      ensure
+        self.current = old_current
+      end
+
+      #
+      # Sets current to nil and yields to the block.
+      # At the end, current is always set back to what it was originally.
+      #
+      def without_tenant
+        old_current = self.current
+        self.current = nil
+        yield if block_given?
+      ensure
+        self.current = old_current
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend MultiTenant::ActsAsTenant

data/lib/multi_tenant/belongs_to_tenant.rb

@@ -0,0 +1,70 @@
+module MultiTenant
+  #
+  # Module with helpers for telling a model that it belongs to a tenant.
+  #
+  module BelongsToTenant
+    #
+    # Bind this models' records to a tenant. You *must* specify the association name, and you *may* follow it
+    # up with any of the standard 'belongs_to' arguments (i.e. a scope and/or an options Hash).
+    #
+    #   class Widget < ActiveRecord::Base
+    #     belongs_to_tenant :customer
+    #   end
+    #
+    # @param association_name [Symbol] Name of the association to the tenant
+    # @param scope [Proc] (optional) Proc holding an Arel scope for the lookup - same that the normal `belongs_to` method accepts.
+    # @param options [Hash] (optional) Hash with association options - same that the normal `belongs_to` methods accepts.
+    #
+    def belongs_to_tenant(association_name, scope = nil, options = {})
+      belongs_to association_name, scope, options
+      reflection = reflections[association_name.to_s]
+      unless reflection.klass.acts_as_tenant? or reflection.klass.proxies_to_tenant?
+        raise "`belongs_to_tenant :#{association_name}` failed because #{reflection.klass.name} has not used `acts_as_tenant` or `proxies_to_tenant`."
+      end
+
+      cattr_accessor :tenant_class, :tenant_foreign_key, :tenant_primary_key
+      self.tenant_class = reflection.klass
+      self.tenant_foreign_key = reflection.foreign_key.to_sym
+      self.tenant_primary_key = reflection.active_record_primary_key.to_sym
+
+      before_validation :assign_to_tenant
+      validates_presence_of tenant_foreign_key
+
+      self.class_eval do
+        include MultiTenant::BelongsToTenant::InstanceMethods
+
+        default_scope {
+          current = tenant_class.current
+          current ? where({tenant_foreign_key => current.send(tenant_primary_key)}) : where('1=1')
+        }
+      end
+    end
+
+    #
+    # Returns true if this model belongs to a tenant.
+    #
+    # @return [Boolean]
+    #
+    def belongs_to_tenant?
+      respond_to? :tenant_class
+    end
+
+    #
+    # Instance methods given to tenant-owned models.
+    #
+    module InstanceMethods
+      private
+
+      #
+      # Assign this model to the current tenant (if any)
+      #
+      def assign_to_tenant
+        if self.class.tenant_class.current and send(self.class.tenant_foreign_key).blank?
+          send "#{self.class.tenant_foreign_key}=", self.class.tenant_class.current.send(self.class.tenant_primary_key)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend MultiTenant::BelongsToTenant

data/lib/multi_tenant/belongs_to_tenant_through.rb

@@ -0,0 +1,49 @@
+module MultiTenant
+  #
+  # Module with helpers for telling a model that it belongs to a tenant through one of its associations.
+  #
+  module BelongsToTenantThrough
+    #
+    # Declare that this model has an association that belongs to a tenant. The assocation must be declared
+    # BEFORE this is called.
+    #
+    #   class User < ActiveRecord::Base
+    #     has_many :memberships
+    #     belongs_to_tenant_through :memberships
+    #   end
+    #
+    # @param association_name [Symbol] Name of the association to the tenant
+    #
+    def belongs_to_tenant_through(association_name)
+      ref = reflections[association_name.to_s]
+      raise "`belongs_to_tenant_through :#{association_name}` failed because the association `:#{association_name}` has not been declared" if ref.nil?
+      raise "`belongs_to_tenant_through :#{association_name}` failed because #{ref.klass.name} has not used `belongs_to_tenant`" unless ref.klass.belongs_to_tenant?
+
+      cattr_accessor :delegate_class
+      self.delegate_class = ref.klass
+
+      self.class_eval do
+        default_scope {
+          tenant = delegate_class.tenant_class.current
+          next where('1=1') if tenant.nil?
+
+          # Using straight sql so we can JOIN against two columns. Otherwise one must go into "WHERE", and Arel would mistakenly apply it to UPDATEs and DELETEs.
+          quoted_tenant_id = connection.quote tenant.send delegate_class.tenant_primary_key
+          joins("INNER JOIN #{ref.klass.table_name} ON #{ref.klass.table_name}.#{ref.foreign_key}=#{table_name}.#{ref.active_record_primary_key} AND #{ref.klass.table_name}.#{ref.klass.tenant_foreign_key}=#{quoted_tenant_id}").
+            readonly(false) # using "joins" makes records readonly, which we don't want
+        }
+      end
+    end
+
+    #
+    # Returns true if this model belongs to a tenant through one of its associations.
+    #
+    # @return [Boolean]
+    #
+    def belongs_to_tenant_through?
+      respond_to? :delegate_class
+    end
+  end
+end
+
+ActiveRecord::Base.extend MultiTenant::BelongsToTenantThrough

data/lib/multi_tenant/middleware.rb

@@ -0,0 +1,114 @@
+require 'set'
+require 'rack'
+
+module MultiTenant
+  #
+  # Rack middleware that sets the current tenant during each request (in a thread-safe manner). During a request,
+  # you can access the current tenant from "Tenant.current", where 'Tenant' is name of the ActiveRecord model.
+  #
+  #   use MultiTenant::Middleware,
+  #     # The ActiveRecord model that represents the tenants. Or a Proc returning it, or it's String name.
+  #     model: -> { Tenant },
+  #
+  #     # A Proc that returns the tenant identifier that's used to look up the tenant. (i.e. :using option passed to acts_as_tenant)
+  #     identifier: ->(req) { req.host.split(/\./)[0] },
+  #
+  #     # (optional) Array of tentants that don't exist in the database, but should be allowed through anyway.
+  #     # IMPORTANT For these, Tenant.current will be nil!
+  #     global_identifiers: %w(global),
+  #
+  #     # (optional) Array of Strings or Regexps for paths that don't require a tenant. Only applies 
+  #     # when the tenant isn't specified in the request - not when a given tenant can't be found.
+  #     global_paths: [
+  #       '/about',
+  #       %r{^/api/v\d+/login$},
+  #     ],
+  #
+  #     # (optional) Returns a Rack response when a tenant couldn't be found in the db, or when
+  #     # a tenant isn't given (and isn't in the `global_paths` list)
+  #     not_found: ->(x) {
+  #       body = {errors: ["'#{x}' is not a valid tenant. I'm sorry. I'm so sorry."]}.to_json
+  #       [400, {'Content-Type' => 'application/json', 'Content-Length' => body.size.to_s}, [body]]
+  #     }
+  #
+  class Middleware
+    # @return [Proc|String|Class] The ActiveRecord model that holds all the tenants
+    attr_accessor :model
+
+    # @return [Proc] A Proc which accepts a Rack::Request and returns some identifier for tenant lookup
+    attr_accessor :identifier
+
+    # @return [Set<String>] array of "fake" identifiers that will be allowed through, but without setting a current tentant
+    attr_accessor :global_identifiers
+
+    # @return [Set<String>] An array of path strings that don't requite a tenant to be given
+    attr_accessor :global_strings
+
+    # @return [Set<String>] An array of path regexes that don't requite a tenant to be given
+    attr_accessor :global_regexes
+
+    # @return [Proc] A Proc which accepts a (non-existent or blank) tenant identifier and returns a rack response describing
+    # the error. Defaults to a 404 and some shitty html.
+    attr_accessor :not_found
+
+    # Default Proc for the not_found option
+    DEFAULT_NOT_FOUND = ->(x) {
+      [404, {'Content-Type' => 'text/html', 'Content-Length' => (33 + x.to_s.size).to_s}, ['<h1>\'%s\' is not a valid tenant</h1>' % x.to_s]]
+    }
+
+    #
+    # Initialize a new multi tenant Rack middleware.
+    #
+    # @param app the Rack app
+    # @param opts [Hash] Required: :model, :identifier. Optional: :global_identifiers, :global_paths, :not_found.
+    #
+    def initialize(app, opts)
+      @app = app
+      self.model = opts.fetch :model
+      self.identifier = opts.fetch :identifier
+      self.global_identifiers = Set.new(Array(opts[:global_identifiers]))
+      self.global_strings = Set.new(Array(opts[:global_paths]).select { |x| x.is_a? String })
+      self.global_regexes = Array(opts[:global_paths]).select { |x| x.is_a? Regexp }
+      self.not_found = opts[:not_found] || DEFAULT_NOT_FOUND
+    end
+
+    # Rack request call
+    def call(env)
+      request = Rack::Request.new env
+      tenant_identifier = identifier.(request)
+
+      if tenant_identifier.blank?
+        if global_strings.include? request.path or global_regexes.any? { |x| x =~ request.path }
+          tenant_class.current = nil
+          return @app.call env
+        else
+          return not_found.(tenant_identifier)
+        end
+      end
+
+      tenant_record = tenant_identifier.present? ? tenant_class.where({tenant_class.tenant_identifier => tenant_identifier}).first : nil
+      if tenant_record
+        tenant_class.current = tenant_record
+        return @app.call env
+      elsif global_identifiers.include? tenant_identifier
+        tenant_class.current = nil
+        return @app.call env
+      else
+        return not_found.(tenant_identifier)
+      end
+    ensure
+      tenant_class.current = nil
+    end
+
+    # Infers and returns the tenant model class this middleware is handling
+    def tenant_class
+      @tenant_class ||= if self.model.respond_to?(:call)
+        self.model.call
+      elsif self.model.respond_to?(:constantize)
+        self.model.constantize
+      else
+        self.model
+      end
+    end
+  end
+end

data/lib/multi_tenant/proxies_to_tenant.rb

@@ -0,0 +1,101 @@
+module MultiTenant
+  #
+  # Helpers for setting a proxy model to your tenant model. So your records can `acts_as_tenant` to the proxy model instead of directly to the tenant.
+  #
+  # However, only certain types of associations are supported. (We could probably support all types, but since each type requires a special implementation, we've only added the ones we've needed so far.)
+  #
+  # Configuration I: has_many, inverse of belongs_to
+  #
+  #     # The tenant model that's hooked up to the Rack middleware and holds the "current" tenant
+  #     class Client < ActiveRecord::Base
+  #       belongs_to :license
+  #       acts_as_tenant
+  #     end
+  #
+  #     # The proxy model that's (potentially) associated with multiple tenants
+  #     class License < ActiveRecord::Base
+  #       has_many :clients, inverse_of: :license
+  #       proxies_to_tenant :clients
+  #     end
+  #
+  #     # Widets will be associated to a License (instead of a Client), therefore they are automatically
+  #     # shared with all Clients who use that License.
+  #     class Widget < ActiveRecord::Base
+  #       belongs_to_tenant :license
+  #       has_many :clients, through: :license # not required - just for clarity
+  #     end
+  #
+  #     # Splines, on the other hand, still belong directly to individual Clients like normal.
+  #     class Spline < ActiveRecord::Base
+  #       belongs_to_tenant :client
+  #     end
+  #
+  #     # This is what's going on behind the scenes. Not too complicated, all things considered.
+  #     License.current == Client.current.license
+  #
+  # Configuration II: has_one, inverse of belongs_to:
+  # License has_one Client, and Client belongs_to License.
+  #
+  # Configuration III: belongs_to, inverse of has_one:
+  # License belongs_to Client, and Client has_one License.
+  #
+  module ProxiesToTenant
+    #
+    # Declare a model as a proxy to tenant model.
+    #
+    # @param association_name [Symbol] the association that's the *real* tenant. You must define the association yourself (e.g. belongs_to) along with the `:inverse_of` option.
+    # @param scope [Proc] (optional) An AR scope that will be run *against the proxy model*, i.e. *this* model. Useful for when the association's `:inverse_of` is a `has_many` or `has_many_and_belongs_to`.
+    #
+    def proxies_to_tenant(association_name, scope = nil)
+      reflection = reflections[association_name.to_s]
+      raise "`proxies_to_tenant :#{association_name}`: unable to find association `:#{association_name}`. Make sure you create the association *first*." if reflection.nil?
+      raise "`proxies_to_tenant :#{association_name}`: #{reflection.klass.name} must use `acts_as_tenant`" if !reflection.klass.acts_as_tenant?
+      raise "`proxies_to_tenant :#{association_name}`: the `:#{association_name}` association must use the `:inverse_of` option." if reflection.inverse_of.nil?
+
+      case [reflection.macro, reflection.inverse_of.macro]
+      when [:has_many, :belongs_to], [:has_one, :belongs_to], [:belongs_to, :has_one]
+        self.extend SingularInverseAssociation
+      else
+        raise "`proxies_to_tenant` does not currently support `#{reflection.macro}` associations with `#{reflection.inverse_of.macro} inverses."
+      end
+
+      cattr_accessor :proxied_tenant_class, :proxied_tenant_inverse_assoc, :proxied_tenant_inverse_scope
+      self.proxied_tenant_class = reflection.klass
+      self.proxied_tenant_inverse_assoc = reflection.inverse_of.name
+      self.proxied_tenant_inverse_scope = scope
+    end
+
+    #
+    # Returns true if this model is proxying to a tenant.
+    #
+    # @return [Boolean]
+    #
+    def proxies_to_tenant?
+      respond_to? :proxied_tenant_class
+    end
+
+    private
+
+    # Class methods for tenant proxies that have a singular inverse association (i.e. belongs_to or has_one).
+    module SingularInverseAssociation
+      # Returns the "current" record of the proxy model
+      def current
+        if (tenant = proxied_tenant_class.current)
+          tenant.send proxied_tenant_inverse_assoc
+        end
+      end
+    end
+
+    # NOTE just some thoughts on *maybe* how to support this if we ever need it.
+    module PluralInverseAssociation
+      # Returns the "current" record of the proxy model
+      def current
+        if (tenant = proxied_tenant_class.current)
+          tenant.send(proxied_tenant_inverse_assoc).instance_eval(&proxied_tenant_inverse_scope).first
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend MultiTenant::ProxiesToTenant

data/lib/multi_tenant/version.rb

@@ -0,0 +1,4 @@
+module MultiTenant
+  # Gem version
+  VERSION = '0.5.0'.freeze
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: acts_as_multi_tenant
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Jordan Hollinger
+- Andrew Coleman
+- Taylor Redden
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An ActiveRecord plugin for multi-tenant databases
+email: jordan.hollinger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/acts_as_multi_tenant.rb
+- lib/multi_tenant/acts_as_tenant.rb
+- lib/multi_tenant/belongs_to_tenant.rb
+- lib/multi_tenant/belongs_to_tenant_through.rb
+- lib/multi_tenant/middleware.rb
+- lib/multi_tenant/proxies_to_tenant.rb
+- lib/multi_tenant/version.rb
+homepage: https://github.com/consolo/acts_as_multi_tenant
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: An ActiveRecord plugin for multi-tenant databases
+test_files: []