rack-multitenant 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  metadata.gz: 8668da451467bac3c7fd343928512230aa796c3a
+  data.tar.gz: 93aa7f15e84a84509103edb89555bae8a877eb64
+SHA512: 
+  metadata.gz: 996ae7d0d9c6aaa00cbe5044b5955005e8c6f8a3a5f4c62af49573a86b04d6c5dbf537d48bcef60eacd39d5a4649bd7d5998db6e9f5ccf1eab6b96bffd092f05
+  data.tar.gz: bf5fe47655d2546955fa1c0136898146545e8b820857972aa4cf65b36d4f28ccb96fc67382f6bcaebd916c7e0bc8760a6d7d7adffa333fa69327f479a431f426

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.swp
+.DS_Store

data/Gemfile

@@ -0,0 +1,19 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rack-multitenant.gemspec
+gemspec
+
+group :development, :test do
+  gem "rake", "~> 10.0.3"
+  gem "pry", "~> 0.9.11"
+
+  gem "activerecord"
+  gem "sinatra"
+  gem "haml"
+  gem "sqlite3"
+end
+
+group :test do
+  gem "rdoctest", "~> 0.0.2"
+  gem "rack-test", "~> 0.6.2"
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Andrew O'Brien
+
+MIT License
+
+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,29 @@
+# Rack::Multitenant
+
+## What?
+
+Many web-applications want to provide a sandboxed instance for each customer, but know that this would be impractical and inefficient. To present the illusion of this, they often provide a subdomain, url prefix, different domain entirely, or something more exotic. Many of these can hamper development or make it hard to reproduce production problems.
+
+Rack::Multitenant provides an interface to allow the application to decide which customer (or _tenant_) the request the for. It will assign the tenant object to the request's environment hash, meaning that all Rack compliant applications will be able to use it.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rack-multitenant'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rack-multitenant
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+require 'rdoctest/task'
+require 'rake/testtask'
+
+namespace :test do
+  Rdoctest::Task.new :unit do |t|
+    #t.libs      << 'lib'          # The 'lib' directory is loaded by default,
+    t.pattern = 'lib/rack/multitenant/**/*.rb'
+  end
+  Rake::TestTask.new :integration do |t|
+    t.libs << "lib"
+    t.test_files = FileList['examples/*_spec.rb']
+    #t.verbose = true
+  end
+end
+
+desc "Run unit and integration tests"
+task :test => %w{test:unit test:integration}

data/examples/example_helper.rb

@@ -0,0 +1,9 @@
+require "rack/test"
+require "minitest/spec"
+require "minitest/autorun"
+require "pry"
+$:.unshift(File.dirname(__FILE__) + "/../lib")
+
+class MiniTest::Unit::TestCase
+  include Rack::Test::Methods
+end

data/examples/get_identity.rb

@@ -0,0 +1,38 @@
+require "rack"
+require "rack/builder"
+require "rack/auth/basic"
+require "rack/multitenant"
+
+ACCOUNTS = {
+  andrew: {
+    foo: :user
+  },
+  vince: {
+    foo: :admin,
+    bar: :user
+  },
+  lou: {}
+}
+
+Get_identity = Rack::Builder.new do
+  use Rack::MultiTenant::GetCurrentTenant do |request|
+    # TODO: subdomain strategy for getting current tenant.
+    request.url =~ /foo/ ?  :foo : :bar
+  end
+  # TODO: replace with Warden
+  use Rack::Auth::Basic do |username, password|
+    username if password == "password" && accounts = ACCOUNTS[username.to_sym]
+  end
+  use Rack::MultiTenant::GetIdentity do |username, tenant|
+    # TODO: DB lookup
+    if identities = ACCOUNTS[username.to_sym] and identity = identities[tenant]
+      ->(app) { app.pass identity } # Or just return identity.
+    else
+      ->(app) { app.forbid! }
+      # -> (app) { app.create_with SignUpWithExisting, identities } or something like this...
+    end
+  end
+  run lambda {|env|
+    [200, {}, "Your identity: #{env['rack.multitenant.identity']}"]
+  }
+end

data/examples/get_identity_spec.rb

@@ -0,0 +1,34 @@
+require_relative "example_helper"
+
+describe "Simple example" do
+  def app
+    @app = Rack::Builder.parse_file('./examples/get_identity.rb').first
+  end
+
+  it "gets the identity for an authorized user of the given tenant" do
+    authorize "andrew", "password"
+    get "/foo"
+    assert last_response.ok?
+    assert_equal("Your identity: user", last_response.body)
+  end
+
+  it "does not allow unauthenticated users" do
+    get "/foo"
+    assert_equal 401, last_response.status
+
+    authorize "andrew", "fail"
+    get "/foo"
+    assert_equal 401, last_response.status
+  end
+
+  it "does not allow in users without an identity for the tenant" do
+    authorize "lou", "password"
+    get "/foo"
+    assert_equal 403, last_response.status
+
+    authorize "andrew", "password"
+    get "/bar"
+    assert_equal 403, last_response.status
+  end
+end
+

data/examples/getter_strategies.rb

@@ -0,0 +1,31 @@
+require "rack"
+require "rack/builder"
+require "rack/auth/basic"
+require "rack/multitenant"
+
+Getter_strategies = Rack::Builder.new do
+  # Builds a piece of middleware that:
+  # 1. First tries to get the tenant from a subdomain
+  # 2. If the RACK_ENV is development or test, it uses a hash to
+  #    look up by port.
+  # 3. Last, if a tenant still hasn't been found, it defaults to a
+  #    hard-coded value.
+  #
+  # The return value of the block will be saved as the value of
+  # <tt>env['rack.multitenant.current_tenant']</tt>.
+  use *Rack::MultiTenant::GetCurrentTenant.build {|builder|
+    builder.use :Subdomain, "example.com"
+    #builder.use :PathPrefix Not implemented. Anyone need this?
+    if %w{development test}.include?(ENV["RACK_ENV"])
+      builder.use :Port, {
+        3000 => :foo,
+        3001 => :bar
+      }
+      #builder.use :EnvVariable
+    end
+    builder.use :Default, :bar
+  }
+  run lambda {|env|
+    [200, {}, "Current tenant: #{env['rack.multitenant.current_tenant']}"]
+  }
+end

data/examples/getter_strategies_spec.rb

@@ -0,0 +1,22 @@
+require_relative "example_helper"
+
+describe "Getter strategies example" do
+  def app
+    @app = Rack::Builder.parse_file('./examples/getter_strategies.rb').first
+  end
+
+  it "gets default tenant" do
+    get "/"
+
+    assert last_response.ok?
+    assert_match /bar/, last_response.body
+  end
+
+  it "gets tenant by subdomain" do
+    get "/", {}, "HTTP_HOST" => "foo.example.com"
+
+    assert last_response.ok?
+    assert_match /foo/, last_response.body
+  end
+end
+

data/examples/multitenant_sinatra.rb

@@ -0,0 +1,169 @@
+# Run with: bundle exec rackup examples/multitenant_sinatra.rb
+
+$:.unshift(File.dirname(__FILE__) + "/../lib")
+require "rubygems"
+require "active_record"
+require "sqlite3"
+require "sinatra"
+require "haml"
+require "rack/builder"
+require "rack/auth/basic"
+require "rack/multitenant"
+require "pry"
+
+def connect_to_db!
+  ActiveRecord::Base.establish_connection(
+    adapter: "sqlite3",
+    database: File.dirname(__FILE__) + "/../tmp/multitenant_sinatra.sqlite3"
+  )
+end
+connect_to_db!
+
+ActiveRecord::Migration.create_table :items, force: true do |t|
+  t.text :text
+  t.integer :tenant_id
+  t.integer :created_by_id
+  t.integer :finished_by_id
+  t.timestamps
+end
+
+ActiveRecord::Migration.create_table :identities, force: true do |t|
+  t.integer :tenant_id
+  t.integer :account_id
+end
+
+ActiveRecord::Migration.create_table :accounts, force: true do |t|
+  t.string :username
+end
+
+ActiveRecord::Migration.create_table :tenants, force: true do |t|
+  t.string :key
+end
+
+class Item < ActiveRecord::Base
+  belongs_to :created_by, class_name: "Identity"
+  belongs_to :finished_by, class_name: "Identity"
+  belongs_to :tenant
+
+  validates :tenant, presence: true
+
+  def self.add(attrs, creator)
+    create(attrs.merge(created_by: creator))
+  end
+
+  def finish!(finisher)
+    update_attributes(finished_by: finisher)
+  end
+
+  def finished?
+    finished_by.present?
+  end
+end
+
+class Tenant < ActiveRecord::Base
+  has_many :todos, class_name: "Item"
+end
+
+class Identity < ActiveRecord::Base
+  belongs_to :account
+  belongs_to :tenant
+end
+
+class Account < ActiveRecord::Base
+  has_many :identities
+end
+
+foo_corp = Tenant.create!(key: "foo")
+bar_inc = Tenant.create!(key: "bar")
+
+andrew = Account.create!(username: "andrew")
+vince = Account.create!(username: "vince")
+lou = Account.create!(username: "lou")
+
+andrew.identities.create!(tenant: foo_corp)
+andrew.identities.create!(tenant: bar_inc)
+vince.identities.create!(tenant: bar_inc)
+
+class HostedTodos < Sinatra::Base
+  get "/" do
+    redirect "/items"
+  end
+
+  post "/items" do
+    tenant.todos.add(params[:item], current_user)
+    redirect "/items"
+  end
+
+  get "/items" do
+    @items = tenant.todos.all
+    haml :items
+  end
+
+  post "/items/:id/finish" do
+    tenant.todos.find(params[:id]).finish!(current_user)
+    redirect "/items"
+  end
+
+  private
+  def tenant
+    env["rack.multitenant.current_tenant"]
+  end
+
+  def current_user
+    env['rack.multitenant.identity']
+  end
+
+  enable :inline_templates
+end
+
+Multitenant_sinatra = Rack::Builder.new do
+  connect_to_db!
+  # Liking this *build method a little less... Probably want to reconsider before releasing.
+  # Just an aesthetic problem--not worth holding things up.
+  use *Rack::MultiTenant::GetCurrentTenant.build {|builder|
+    builder.use :Subdomain, "example.com" do |key|
+      Tenant.find_by_key(key)
+    end
+    builder.use :Default, bar_inc
+  }
+  use Rack::Auth::Basic do |username, password|
+    # In a real example, we could do a couple of things:
+    #
+    #  * Multi-identity, single password: store the auth credentials on the Account
+    #  * Multi-identity, multi-auth strategy: Move the credentials to the Identity.
+    #    Scope your find to the current tenant.
+    password == "password" && account = Account.find_by_username(username.to_sym)
+  end
+  use Rack::MultiTenant::GetIdentity do |account_name, tenant|
+    # Rack::Basic only keeps the username. In a real app, we'd use something that only
+    # made us hit the Account table once per request (like Warden).
+    account = Account.find_by_username(account_name)
+    Identity.where(account_id: account.id, tenant_id: tenant.id).first
+  end
+  run HostedTodos
+end
+
+__END__
+
+@@ layout
+%html
+  = yield
+
+@@ items
+%form(action="/items" method="POST")
+  %p
+    %label(for="text") Text:
+    %input#text(type="text" name="item[text]")
+  %p
+    %input(type="submit" value="Create")
+
+.items
+  - @items.each do |item|
+    %p
+      - if item.finished?
+        %del
+          = item.text
+      - else
+        = item.text
+        %form{:action => "/items/#{item.id}/finish", :method => "POST"}
+          %input(type="submit" value="Finish")

data/lib/rack-multitenant.rb

@@ -0,0 +1,3 @@
+require "rack-multitenant/version"
+
+require "rack/multitenant"

data/lib/rack-multitenant/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  module Multitenant
+    VERSION = "1.0.0"
+  end
+end

data/lib/rack/multitenant.rb

@@ -0,0 +1,13 @@
+module Rack
+  module MultiTenant
+    autoload :GetCurrentTenant, "rack/multitenant/get_current_tenant"
+    autoload :GetIdentity, "rack/multitenant/get_identity"
+
+    module TenantStrategies
+      autoload :Subdomain, "rack/multitenant/tenant_strategies/subdomain"
+      autoload :Port, "rack/multitenant/tenant_strategies/port"
+      autoload :EnvVariable, "rack/multitenant/tenant_strategies/env_variable"
+      autoload :Default, "rack/multitenant/tenant_strategies/default"
+    end
+  end
+end

data/lib/rack/multitenant/get_current_tenant.rb

@@ -0,0 +1,98 @@
+require_relative "../multitenant"
+require "rack/request"
+
+module Rack::MultiTenant
+  class GetCurrentTenant
+    # Convenience method for initializing the GetCurrentTenant middleware
+    # with a stack of strategies.
+    #
+    #   >> GetCurrentTenant = Rack::MultiTenant::GetCurrentTenant
+    # A custom getter that will be instantiated once and called.
+    #   >> class MyCustomGetter
+    #   >>   def initialize(host)
+    #   >>     @host = host
+    #   >>   end
+    #   >>   def call(req)
+    #   >>     req.host == @host ? :custom : nil
+    #   >>   end
+    #   >> end
+    #
+    #   >> # Stub the rest of the Rack stack to return the env value we're
+    #   >> # interested in.
+    #   >> next_app = lambda {|env| env["rack.multitenant.current_tenant"]}
+    #
+    #   >> # Build the middleware and instantiate it.
+    #   >> app = GetCurrentTenant.new(next_app, GetCurrentTenant.build do |get|
+    #   >>   get.use :Subdomain, "example.com", &:to_sym
+    #   >>   get.use MyCustomGetter, "custom"
+    #   >>   get.use lambda {|req| req.host == "lambda" ? :lambda : nil }
+    #   >>   get.use :Default, :default_tenant
+    #   >> end[1])
+    #
+    #   >> subdomain_req_env = {"HTTP_HOST" => "foo.example.com"}
+    #   >> app.call(subdomain_req_env)
+    #   => :foo
+    #
+    #   >> custom_req_env = {"HTTP_HOST" => "custom"}
+    #   >> app.call(custom_req_env)
+    #   => :custom
+    #   
+    #   >> lambda_req_env = {"HTTP_HOST" => "lambda"}
+    #   >> app.call(lambda_req_env)
+    #   => :lambda
+    #   
+    #   >> default_req_env = {"HTTP_HOST" => "kwjibo"}
+    #   >> app.call(default_req_env)
+    #   => :default_tenant
+    def self.build
+      [self, (Builder.new.tap {|b| yield b}).to_proc]
+    end
+
+    def initialize(app, foo = nil, &getter)
+      @app, @getter = app, foo || getter
+    end
+
+    def call(env)
+      if tenant = @getter.call(Rack::Request.new(env))
+        env["rack.multitenant.current_tenant"] = tenant
+      end
+      @app.call(env)
+    end
+
+    class Builder
+      def initialize
+        @stack = []
+      end
+
+      def use(name, *args, &blk)
+        @stack << case strategy = resolve(name)
+        when Class
+          strategy.new(*args, &blk)
+        else
+          strategy
+        end
+      end
+      alias_method :with, :use
+
+      def to_proc
+        _stack = @stack.compact
+        lambda {|request|
+          tenant = nil
+          _stack.find {|strategy| tenant = strategy.call(request)}
+          tenant
+        }
+      end
+
+      private
+      def resolve(name)
+        case name
+        when Symbol
+          Rack::MultiTenant::TenantStrategies.const_get(name)
+        else
+          name
+        end
+      end
+    end
+  end
+end
+

data/lib/rack/multitenant/get_identity.rb

@@ -0,0 +1,45 @@
+module Rack::MultiTenant
+  class GetIdentity
+    def initialize(app, user_key = "REMOTE_USER", &getter)
+      @app, @user_key, @getter = app, user_key, getter
+    end
+
+    def call(env)
+      user, tenant = env.values_at(@user_key, "rack.multitenant.current_tenant")
+      Next.new(@app, env).call(@getter.call(user, tenant))
+    end
+
+    class Next
+      def initialize(app, env)
+        @app, @env = app, env
+      end
+
+      def call(result)
+        case result
+        when Proc
+          result.call(self)
+        when nil
+          forbid!
+        when false
+          forbid!
+        else
+          pass result
+        end
+      end
+
+      def pass(identity)
+        @env["rack.multitenant.identity"] = identity
+        @app.call(@env)
+      end
+
+      def forbid!(forbidden_app = nil)
+        [403, {"Content-Type" => "text/html"},
+          "No identity found for #{@env['rack.multitenant.current_tenant']}"]
+      end
+
+      def create_identity_with(subapp)
+        # TODO: calls subapp that either creates or gets the user on the path to creating a new identity.
+      end
+    end
+  end
+end

data/lib/rack/multitenant/tenant_strategies/default.rb

@@ -0,0 +1,18 @@
+require "rack/multitenant"
+
+module Rack::MultiTenant::TenantStrategies
+  # Always returns the intial value for tenant.
+  #
+  #   >> default = Rack::MultiTenant::TenantStrategies::Default.new(:foo)
+  #   >> default.call(:stub_request)
+  #   => :foo
+  class Default
+    def initialize(default)
+      @default = default
+    end
+
+    def call(_)
+      @default
+    end
+  end
+end

data/lib/rack/multitenant/tenant_strategies/env_variable.rb

@@ -0,0 +1,22 @@
+module Rack::MultiTenant::TenantStrategies
+  class EnvVariable
+    # env: Environment variable containing the tenant or tenant key.
+    # &getter: optional block. If specified, the env variable will be passed in.
+    #
+    #   >> ENV["TENANT"] = "foo"
+    #   >> s = Rack::MultiTenant::TenantStrategies::EnvVariable.new
+    #   >> s.call(:stub_request)
+    #   => "foo"
+    #
+    #   >> s2 = Rack::MultiTenant::TenantStrategies::EnvVariable.new(&:to_sym)
+    #   >> s2.call(:stub_request)
+    #   => :foo
+    def initialize(env = ENV["TENANT"], &getter)
+      @env = (getter || lambda {|k| k}).call(env)
+    end
+
+    def call(_)
+      @env
+    end
+  end
+end

data/lib/rack/multitenant/tenant_strategies/port.rb

@@ -0,0 +1,19 @@
+module Rack::MultiTenant::TenantStrategies
+  class Port
+    # port_map: A hash of ports to tenants
+    #
+    #   >> require "ostruct"
+    #   >> ports = {3000 => :foo, 3001 => :bar}
+    #   >> req = OpenStruct.new(port: 3001)
+    #   >> s = Rack::MultiTenant::TenantStrategies::Port.new(ports)
+    #   >> s.call(req)
+    #   => :bar
+    def initialize(port_map)
+      @port_map = port_map
+    end
+
+    def call(request)
+      tenant = @port_map[request.port]
+    end
+  end
+end

data/lib/rack/multitenant/tenant_strategies/subdomain.rb

@@ -0,0 +1,40 @@
+module Rack::MultiTenant::TenantStrategies
+  class Subdomain
+    # Gets a tenant by subdomain.
+    #
+    # Optionally takes a block that transforms the tenant string into a
+    # proper tenant.
+    #
+    #   >> Sub =  Rack::MultiTenant::TenantStrategies::Subdomain
+    #   >> require "ostruct"
+    #
+    #   >> foo_req = OpenStruct.new(host: "foo.example.com")
+    #   >> strat = Sub.new(".example.com")
+    #   >> strat.call(foo_req)
+    #   => "foo"
+    #
+    #   >> strat_with_getter = Sub.new("example.com", &:to_sym)
+    #   >> strat_with_getter.call(foo_req)
+    #   => :foo
+    #
+    #   >> wrong_host_req = OpenStruct.new(host: "localhost")
+    #   >> strat.call(wrong_host_req)
+    #   => nil
+    def initialize(domain, &getter)
+      @domain, @getter = domain, getter || lambda {|k| k}
+    end
+
+    def call(request)
+     if subdomain = subdomain(request.host, @domain)
+       @getter.call(subdomain)
+      end
+    end
+
+    private
+    def subdomain(host, domain)
+      if loc = host.rindex(domain)
+        host[0, loc].chomp(".")
+      end
+    end
+  end
+end

data/rack-multitenant.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rack-multitenant/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "rack-multitenant"
+  gem.version       = Rack::Multitenant::VERSION
+  gem.authors       = ["Andrew O'Brien"]
+  gem.email         = ["andrew@econify.com"]
+  gem.description   = %q{Rack middleware for scoping requests and sharing accounts.}
+  gem.summary       = %q{For multitenant applications with shared accounts but different data. Scope requests to the tenant when before it enters the app.}
+  gem.homepage      = "https://github.com/Econify/rack-multitenant"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(examples|test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency "rack", "~> 1.4.0"
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: rack-multitenant
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Andrew O'Brien
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-04-22 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.4.0
+  type: :runtime
+  version_requirements: *id001
+description: Rack middleware for scoping requests and sharing accounts.
+email: 
+- andrew@econify.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/example_helper.rb
+- examples/get_identity.rb
+- examples/get_identity_spec.rb
+- examples/getter_strategies.rb
+- examples/getter_strategies_spec.rb
+- examples/multitenant_sinatra.rb
+- lib/rack-multitenant.rb
+- lib/rack-multitenant/version.rb
+- lib/rack/multitenant.rb
+- lib/rack/multitenant/get_current_tenant.rb
+- lib/rack/multitenant/get_identity.rb
+- lib/rack/multitenant/tenant_strategies/default.rb
+- lib/rack/multitenant/tenant_strategies/env_variable.rb
+- lib/rack/multitenant/tenant_strategies/port.rb
+- lib/rack/multitenant/tenant_strategies/subdomain.rb
+- rack-multitenant.gemspec
+homepage: https://github.com/Econify/rack-multitenant
+licenses: []
+
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - &id002 
+    - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id002
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: For multitenant applications with shared accounts but different data. Scope requests to the tenant when before it enters the app.
+test_files: 
+- examples/example_helper.rb
+- examples/get_identity.rb
+- examples/get_identity_spec.rb
+- examples/getter_strategies.rb
+- examples/getter_strategies_spec.rb
+- examples/multitenant_sinatra.rb
+has_rdoc: