sandboxy 3.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 179b0c17257a3a969fee06ad285d9e832a5f4b90adfbeb3e1b8bd2c8eef0a45b
-  data.tar.gz: e6eb6c261f8abee9fb55c15c4d51ccd284953ecfc3727397eaaf1519f1fed29b
+  metadata.gz: dc3184bd2874e25d0f5cb34fd99a14426335abaed4cc600081025f64d50f9f79
+  data.tar.gz: f1886b9a873a7ff1371e3854eeb440f4c09a36c85e9661931a425ca38cdd6472
 SHA512:
-  metadata.gz: 43b75cf5aa42131b4bca6ae0d9c2b3bfaa90d6b88453de2d75401b6c28a27da69b8589f6cbebdd55dba68ddcdb9e7f79acd1f4704a6826f4f15905505e7a8436
-  data.tar.gz: 050d0c42b7b47bffbc1161b38d184ba315d7bbd2431fefb5efc53dea25d1a25fb0923937cec88bdbd83e74b888b2a021a2308399ca8a5218d3c943fc2bbd5ba9
+  metadata.gz: 66edca9dfd3663e9694a6c3f952bf3a5a7dd4aeae1bc5916705524511467466fbbb9736355c7f5e5de0bbe33a78ef383610bb8b32cbb5e5192d60739b9b31d76
+  data.tar.gz: 8e5294a1d6f591f8c57db56370b87af869410e7f00b91ee37b23383c52e3aecd4f736ca5423bde18a720984c6a544e6cbf99ed7577df7af9eb4edbe9d6815a73

data/README.md

@@ -1,228 +1,198 @@
-# Sandboxy
-
-[![Gem Version](https://badge.fury.io/rb/sandboxy.svg)](https://badge.fury.io/rb/sandboxy) <img src="https://travis-ci.org/jonhue/sandboxy.svg?branch=master" />
-
-Sandboxy allows you to use virtual data-oriented environments inside a Rails application while being able to switch between them at runtime. It achieves that by using a combination of Rack Middleware and ActiveRecord.
-
----
-
-## Table of Contents
-
-* [Installation](#installation)
-* [Usage](#usage)
-    * [Setup](#setup)
-    * [`sandboxy` methods](#sandboxy-methods)
-    * [Switching environments](#switching-environments)
-        * [Sandbox & APIs](#sandbox--apis)
-* [Configuration](#configuration)
-* [Testing](#testing)
-    * [Test Coverage](#test-coverage)
-* [To Do](#to-do)
-* [Contributing](#contributing)
-    * [Contributors](#contributors)
-    * [Semantic versioning](#semantic-versioning)
-* [License](#license)
-
----
-
-## Installation
-
-Sandboxy works with Rails 5 onwards. You can add it to your `Gemfile` with:
-
-```ruby
-gem 'sandboxy'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install sandboxy
-
-If you always want to be up to date fetch the latest from GitHub in your `Gemfile`:
-
-```ruby
-gem 'sandboxy', github: 'jonhue/sandboxy'
-```
-
-Now run the generator:
-
-    $ rails g sandboxy
-
-To wrap things up, migrate the changes into your database:
-
-    $ rails db:migrate
-
-## Usage
-
-### Setup
-
-Add Sandboxy to the models where you want to separate records depending on their environments:
-
-```ruby
-class Foo < ApplicationRecord
-    sandboxy
-end
-```
-
-In most use cases you would want to add `sandboxy` to a lot of ActiveRecord models if not all. To simplify that you could create a new class and let all your models inherit from it:
-
-```ruby
-class SharedSandbox < ApplicationRecord
-    self.abstract_class = true
-    sandboxy
-end
-
-class Foo < SharedSandbox
-end
-```
-
-### `sandboxy` methods
-
-By default you can only access records belonging to the current environment (defined by `Sandboxy.environment`):
-
-```ruby
-Sandboxy.environment = 'test'
-Foo.all # => returns all test foo's
-Sandboxy.environment = 'sandbox'
-Foo.all # => returns all sandbox foo's
-```
-
-Now to access the records belonging to a certain environment regardless of your current environment, you can use:
-
-```ruby
-Foo.live_environment # => returns all live foo's
-Foo.sandbox_environment # => returns all sandbox foo's
-Foo.desandbox # => returns all foo's
-```
-
-Let's check to which environment this `Foo` belongs:
-
-```ruby
-foo = Foo.create!
-foo.live_environment? # => false
-foo.sandbox_environment? # => true
-```
-
-You should keep in mind that when you create a new record, it will automatically belong to your app's current environment.
-
-Don't worry, you can move records between environments:
-
-```ruby
-foo.move_environment_live
-foo.live_environment? # => true
-foo.move_environment_sandbox
-foo.sandbox_environment? # => true
-```
-
-### Switching environments
-
-At runtime you can always switch environments anywhere in your application by setting `Sandboxy.environment`. You can set it to any string you like. That makes Sandboxy super flexible.
-
-```ruby
-Sandboxy.environment = 'live'
-Sandboxy.live_environment? # => true
-Sandboxy.sandbox_environment? # => true
-```
-
-#### Sandbox & APIs
-
-It's flexibility allows Sandboxy to work really well with APIs.
-
-Typically an API provides two sets of authentication credentials for a consumer - one for live access and one for sandbox/testing.
-
-Whenever you authenticate your API's consumer, just make sure to set `Sandboxy.environment` accordingly to the credential the consumer used. From thereon, Sandboxy will make sure that your consumer only reads & updates data from the environment he is in.
-
----
-
-## Configuration
-
-You can configure Sandboxy by passing a block to `configure`. This can be done in `config/initializers/sandboxy.rb`:
-
-```ruby
-Sandboxy.configure do |config|
-    config.default = 'sandbox'
-end
-```
-
-**`default`** Set your environment default. This is the environment that your app boots with. By default it gets refreshed with every new request to your server. Takes a string. Defaults to `'live'`.
-
-**`retain`** Retain your current app environment on new requests. If set to `false`, your app will return to your default environment on every new request. Takes a boolean. Defaults to `false`.
-
----
-
-## Testing
-
-Tests are written with Shoulda on top of `Test::Unit` with Factory Girl being used instead of fixtures. Tests are run using rake.
-
-1. Fork this repository
-2. Clone your forked git locally
-3. Install dependencies
-
-    `$ bundle install`
-
-4. Run tests
-
-    `$ rake test`
-
-### Test Coverage
-
-Test coverage can be calculated using SimpleCov. Make sure you have the [simplecov gem](https://github.com/colszowka/simplecov) installed.
-
-1. Add SimpleCov to the Gemfile
-2. Uncomment the relevant section in `test/test_helper.rb`
-3. Run tests
-
-    `$ rake test`
-
----
-
-## To Do
-
-[Here](https://github.com/jonhue/sandboxy/projects/1) is the full list of current projects.
-
-To propose your ideas, initiate the discussion by adding a [new issue](https://github.com/jonhue/sandboxy/issues/new).
-
----
-
-## Contributing
-
-We hope that you will consider contributing to Sandboxy. Please read this short overview for some information about how to get started:
-
-[Learn more about contributing to this repository](https://github.com/jonhue/sandboxy/blob/master/CONTRIBUTING.md), [Code of Conduct](https://github.com/jonhue/sandboxy/blob/master/CODE_OF_CONDUCT.md)
-
-### Contributors
-
-Give the people some :heart: who are working on this project. See them all at:
-
-https://github.com/jonhue/sandboxy/graphs/contributors
-
-### Semantic Versioning
-
-Sandboxy follows Semantic Versioning 2.0 as defined at http://semver.org.
-
-## License
-
-MIT License
-
-Copyright (c) 2017 Jonas Hübotter
-
-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.
+# Sandboxy
+
+[![Gem Version](https://badge.fury.io/rb/sandboxy.svg)](https://badge.fury.io/rb/sandboxy) ![Travis](https://travis-ci.org/jonhue/sandboxy.svg?branch=master)
+
+Sandboxy allows you to use virtual data-oriented environments inside a Rails application while being able to switch between them at runtime. It achieves that by using a combination of Rack Middleware and ActiveRecord.
+
+---
+
+## Table of Contents
+
+* [Installation](#installation)
+* [Usage](#usage)
+  * [Setup](#setup)
+  * [`sandboxy` methods](#sandboxy-methods)
+  * [Switching environments](#switching-environments)
+    * [Sandbox & APIs](#sandbox--apis)
+* [Configuration](#configuration)
+* [Testing](#testing)
+  * [Test Coverage](#test-coverage)
+* [To do](#to-do)
+* [Contributing](#contributing)
+  * [Contributors](#contributors)
+  * [Semantic versioning](#semantic-versioning)
+* [License](#license)
+
+---
+
+## Installation
+
+Sandboxy works with Rails 5 onwards. You can add it to your `Gemfile` with:
+
+```ruby
+gem 'sandboxy'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sandboxy
+
+If you always want to be up to date fetch the latest from GitHub in your `Gemfile`:
+
+```ruby
+gem 'sandboxy', github: 'jonhue/sandboxy'
+```
+
+Now run the generator:
+
+    $ rails g sandboxy
+
+To wrap things up, migrate the changes into your database:
+
+    $ rails db:migrate
+
+## Usage
+
+### Setup
+
+Add Sandboxy to the models where you want to separate records depending on their environments:
+
+```ruby
+class Foo < ApplicationRecord
+  sandboxy
+end
+```
+
+In most use cases you would want to add `sandboxy` to a lot of ActiveRecord models if not all. To simplify that you could create a new class and let all your models inherit from it:
+
+```ruby
+class SharedSandbox < ApplicationRecord
+  self.abstract_class = true
+  sandboxy
+end
+
+class Foo < SharedSandbox
+end
+```
+
+### `sandboxy` methods
+
+By default you can only access records belonging to the current environment (defined by `Sandboxy.environment`):
+
+```ruby
+Sandboxy.environment = 'test'
+Foo.all # => returns all test foo's
+Sandboxy.environment = 'sandbox'
+Foo.all # => returns all sandbox foo's
+```
+
+Now to access the records belonging to a certain environment regardless of your current environment, you can use:
+
+```ruby
+Foo.live_environment # => returns all live foo's
+Foo.sandbox_environment # => returns all sandbox foo's
+Foo.desandbox # => returns all foo's
+```
+
+Let's check to which environment this `Foo` belongs:
+
+```ruby
+foo = Foo.create!
+foo.live_environment? # => false
+foo.sandbox_environment? # => true
+```
+
+You should keep in mind that when you create a new record, it will automatically belong to your app's current environment.
+
+Don't worry, you can move records between environments:
+
+```ruby
+foo.move_environment_live
+foo.live_environment? # => true
+foo.move_environment_sandbox
+foo.sandbox_environment? # => true
+```
+
+### Switching environments
+
+At runtime you can always switch environments anywhere in your application by setting `Sandboxy.environment`. You can set it to any string you like. That makes Sandboxy super flexible.
+
+```ruby
+Sandboxy.environment = 'live'
+Sandboxy.live_environment? # => true
+Sandboxy.sandbox_environment? # => false
+```
+
+#### Sandbox & APIs
+
+It's flexibility allows Sandboxy to work really well with APIs.
+
+Typically an API provides two sets of authentication credentials for a consumer - one for live access and one for sandbox/testing.
+
+Whenever you authenticate your API's consumer, just make sure to set `Sandboxy.environment` accordingly to the credential the consumer used. From thereon, Sandboxy will make sure that your consumer only reads & updates data from the environment he is in.
+
+---
+
+## Configuration
+
+You can configure Sandboxy by passing a block to `configure`. This can be done in `config/initializers/sandboxy.rb`:
+
+```ruby
+Sandboxy.configure do |config|
+  config.default = 'sandbox'
+end
+```
+
+**`default`** Set your environment default. This is the environment that your app boots with. By default it gets refreshed with every new request to your server. Takes a string. Defaults to `'live'`.
+
+**`retain`** Retain your current app environment on new requests. If set to `false`, your app will return to your default environment on every new request. Takes a boolean. Defaults to `false`.
+
+---
+
+## Testing
+
+Tests are written with Shoulda on top of `Test::Unit` with Factory Girl being used instead of fixtures. Tests are run using rake.
+
+1. Fork this repository
+2. Clone your forked git locally
+3. Install dependencies
+
+    $ bundle install
+
+4. Run tests
+
+    $ rake test
+
+### Test Coverage
+
+Test coverage can be calculated using SimpleCov. Make sure you have the [simplecov gem](https://github.com/colszowka/simplecov) installed.
+
+1. Add SimpleCov to the Gemfile
+2. Uncomment the relevant section in `test/test_helper.rb`
+3. Run tests
+
+    $ rake test
+
+---
+
+## To do
+
+We use [GitHub projects](https://github.com/jonhue/sandboxy/projects/1) to coordinate the work on this project.
+
+To propose your ideas, initiate the discussion by adding a [new issue](https://github.com/jonhue/sandboxy/issues/new).
+
+---
+
+## Contributing
+
+We hope that you will consider contributing to Sandboxy. Please read this short overview for some information about how to get started:
+
+[Learn more about contributing to this repository](CONTRIBUTING.md), [Code of Conduct](CODE_OF_CONDUCT.md)
+
+### Semantic Versioning
+
+Sandboxy follows Semantic Versioning 2.0 as defined at http://semver.org.

data/app/models/sandbox.rb

@@ -1,7 +1,7 @@
-class Sandbox < ApplicationRecord
-
-    self.table_name = 'sandboxy'
-
-    belongs_to :sandboxed, polymorphic: true
-
-end
+# frozen_string_literal: true
+
+class Sandbox < ApplicationRecord
+  self.table_name = 'sandboxy'
+
+  belongs_to :sandboxed, polymorphic: true
+end

data/lib/generators/sandboxy_generator.rb

@@ -1,39 +1,36 @@
+# frozen_string_literal: true
+
 require 'rails/generators'
 require 'rails/generators/migration'
 
 class SandboxyGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
 
-    include Rails::Generators::Migration
-
-    source_root File.join File.dirname(__FILE__), 'templates'
-    desc 'Install sandboxy'
+  source_root File.join File.dirname(__FILE__), 'templates'
+  desc 'Install sandboxy'
 
-    def self.next_migration_number dirname
-        if ActiveRecord::Base.timestamped_migrations
-            Time.now.utc.strftime '%Y%m%d%H%M%S'
-        else
-            "%.3d" % (current_migration_number(dirname) + 1)
-        end
+  def self.next_migration_number(dirname)
+    if ActiveRecord::Base.timestamped_migrations
+      Time.now.utc.strftime('%Y%m%d%H%M%S')
+    else
+      format('%.3d', current_migration_number(dirname) + 1)
     end
+  end
 
-    def create_initializer
-        template 'initializer.rb', 'config/initializers/sandboxy.rb'
-    end
+  def create_initializer
+    template 'initializer.rb', 'config/initializers/sandboxy.rb'
+  end
 
-    def create_migration_file
-        migration_template 'migration.rb.erb', 'db/migrate/sandboxy_migration.rb', migration_version: migration_version
-    end
+  def create_migration_file
+    migration_template 'migration.rb.erb', 'db/migrate/sandboxy_migration.rb',
+                       migration_version: migration_version
+  end
 
-    def show_readme
-        readme 'README.md'
-    end
-
-    private
+  private
 
-    def migration_version
-        if Rails.version >= '5.0.0'
-            "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
-        end
-    end
+  def migration_version
+    return unless Rails.version >= '5.0.0'
 
+    "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+  end
 end

data/lib/generators/templates/initializer.rb

@@ -1,13 +1,13 @@
-Sandboxy.configure do |config|
-
-    # Set your environment default. This is the environment that your app boots with.
-    # By default it gets refreshed with every new request to your server.
-    # Takes a string.
-    # config.default = 'live'
-
-    # Retain your current app environment on new requests.
-    # If set to `false`, your app will return to your default environment on every new request.
-    # Takes a boolean.
-    # config.retain = false
-
-end
+# frozen_string_literal: true
+
+Sandboxy.configure do |config|
+  # Set your environment default. This is the environment that your app boots
+  # with. By default it gets refreshed with every new request to your server.
+  # Takes a string.
+  # config.default = 'live'
+
+  # Retain your current app environment on new requests. If set to `false`, your
+  # app will return to your default environment on every new request. Takes a
+  # boolean.
+  # config.retain = false
+end

data/lib/generators/templates/migration.rb.erb

@@ -1,9 +1,9 @@
 class SandboxyMigration < ActiveRecord::Migration<%= migration_version %>
-    def change
-        create_table :sandboxy do |t|
-            t.references :sandboxed, polymorphic: true, index: true
-            t.string :environment, index: true
-            t.timestamps
-        end
+  def change
+    create_table :sandboxy do |t|
+      t.references :sandboxed, polymorphic: true, index: true
+      t.string :environment, index: true
+      t.timestamps
     end
+  end
 end

data/lib/sandboxy.rb

@@ -1,14 +1,14 @@
+# frozen_string_literal: true
+
 require 'sandboxy/version'
 
 module Sandboxy
+  require 'sandboxy/configuration'
 
-    require 'sandboxy/configuration'
-
-    require 'sandboxy/engine'
-
-    autoload :Sandboxed, 'sandboxy/sandboxed'
+  require 'sandboxy/engine'
 
-    require 'sandboxy/middleware'
-    require 'sandboxy/railtie'
+  autoload :Sandboxed, 'sandboxy/sandboxed'
 
+  require 'sandboxy/middleware'
+  require 'sandboxy/railtie'
 end

data/lib/sandboxy/configuration.rb

@@ -1,48 +1,47 @@
-module Sandboxy
-
-    class << self
-        attr_accessor :configuration
-
-        def environment
-            $sandboxy ||= Sandboxy.configuration.default
-            $sandboxy
-        end
-
-        def environment= value
-            $sandboxy = value
-        end
-
-        def method_missing m, *args
-            if m.to_s[/(.+)_environment?/]
-                self.environment? $1
-            else
-                super
-            end
-        end
-
-        def respond_to? m, include_private = false
-            super || m.to_s[/(.+)_environment?/]
-        end
-
-        def environment? value
-            self.environment == value
-        end
-    end
-
-    def self.configure
-        self.configuration ||= Configuration.new
-        yield configuration
-    end
-
-    class Configuration
-
-        attr_accessor :default
-        attr_accessor :retain
-
-        def initialize
-            @default = 'live'
-            @retain = false
-        end
-
-    end
-end
+# frozen_string_literal: true
+
+module Sandboxy
+  class << self
+    attr_accessor :configuration
+
+    def environment
+      $sandboxy ||= Sandboxy.configuration.default
+      $sandboxy
+    end
+
+    def environment=(value)
+      $sandboxy = value
+    end
+
+    def method_missing(method, *args)
+      if method.to_s[/(.+)_environment?/]
+        environment?($1)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      super || method.to_s[/(.+)_environment?/]
+    end
+
+    def environment?(value)
+      environment == value
+    end
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield configuration
+  end
+
+  class Configuration
+    attr_accessor :default
+    attr_accessor :retain
+
+    def initialize
+      @default = 'live'
+      @retain = false
+    end
+  end
+end

data/lib/sandboxy/engine.rb

@@ -1,6 +1,8 @@
-require 'rails/railtie'
-
-module Sandboxy
-    class Engine < ::Rails::Engine
-    end
-end
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+module Sandboxy
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/sandboxy/middleware.rb

@@ -1,18 +1,20 @@
-module Sandboxy
-    class Middleware
-
-        def initialize app
-            @app = app
-        end
-
-        def call env
-            require 'sandboxy'
-
-            previous_environment = Sandboxy.environment
-            $sandboxy = nil
-
-            puts "Sandboxy: Moved to #{Sandboxy.configuration.default} environment" if Sandboxy.environment != previous_environment
-        end
-
-    end
-end
+# frozen_string_literal: true
+
+module Sandboxy
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(_env)
+      require 'sandboxy'
+
+      previous_environment = Sandboxy.environment
+      $sandboxy = nil
+
+      return unless Sandboxy.environment != previous_environment
+
+      puts "Sandboxy: Moved to #{Sandboxy.configuration.default} environment"
+    end
+  end
+end

data/lib/sandboxy/railtie.rb

@@ -1,23 +1,24 @@
+# frozen_string_literal: true
+
 require 'rails/railtie'
 require 'active_record'
 
-
 module Sandboxy
-    class Railtie < Rails::Railtie
-
-        initializer 'sandboxy.active_record' do
-            ActiveSupport.on_load :active_record do
-                include Sandboxy::Sandboxed
-            end
-        end
-
-        initializer 'sandboxy.middleware' do |app|
-            app.middleware.use(Sandboxy::Middleware) unless Sandboxy.configuration&.retain
-        end
+  class Railtie < Rails::Railtie
+    initializer 'sandboxy.active_record' do
+      ActiveSupport.on_load :active_record do
+        include Sandboxy::Sandboxed
+      end
+    end
 
-        config.after_initialize do
-            puts "Sandboxy: Using #{Sandboxy.configuration.default} environment"
-        end
+    initializer 'sandboxy.middleware' do |app|
+      unless Sandboxy.configuration&.retain
+        app.middleware.use(Sandboxy::Middleware)
+      end
+    end
 
+    config.after_initialize do
+      puts "Sandboxy: Using #{Sandboxy.configuration.default} environment"
     end
+  end
 end

data/lib/sandboxy/sandboxed.rb

@@ -1,102 +1,114 @@
+# frozen_string_literal: true
+
 module Sandboxy
-    module Sandboxed
+  module Sandboxed
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
-        def self.included base
-            base.extend ClassMethods
-        end
+    module ClassMethods
+      def sandboxy
+        has_one :sandbox, as: :sandboxed, dependent: :destroy
+        before_create :set_environment
+        include Sandboxy::Sandboxed::SandboxyInstanceMethods
 
-        module ClassMethods
-
-            def sandboxy
-                has_one :sandbox, as: :sandboxed, dependent: :destroy
-                before_create :set_environment
-                include Sandboxy::Sandboxed::InstanceMethods
-
-                default_scope { self.environment_scoped(Sandboxy.environment) }
-                scope :desandbox, -> { unscope(:joins, :where).all }
-
-                def method_missing m, *args
-                    if m.to_s[/(.+)_environment/]
-                        self.environment $1
-                    elsif m.to_s[/(.+)_environment_scoped/]
-                        self.environment_scoped $1
-                    else
-                        super
-                    end
-                end
-
-                def respond_to? m, include_private = false
-                    super || m.to_s[/(.+)_environment/] || m.to_s[/(.+)_environment_scoped/]
-                end
-
-                def environment value
-                    unscope(:joins, :where).environment_scoped value
-                end
-
-                def environment_scoped value
-                    case value
-                    when Sandboxy.configuration.default
-                        left_outer_joins(:sandbox).where sandboxy: { environment: nil }
-                    else
-                        left_outer_joins(:sandbox).where sandboxy: { environment: value }
-                    end
-                end
-            end
+        default_scope { environment_scoped(Sandboxy.environment) }
+        scope :desandbox, -> { unscope(:joins, :where).all }
 
+        class << self
+          include Sandboxy::Sandboxed::SandboxyClassMethods
         end
+      end
+    end
 
-        module InstanceMethods
-
-            def method_missing m, *args
-                if m.to_s[/move_environment_(.+)/]
-                    self.move_environment $1
-                elsif m.to_s[/(.+)_environment?/]
-                    self.environment? $1
-                else
-                    super
-                end
-            end
-
-            def respond_to? m, include_private = false
-                super || m.to_s[/move_environment_(.+)/] || m.to_s[/(.+)_environment?/]
-            end
-
-            def move_environment value
-                case value
-                when Sandboxy.configuration.default
-                    Sandbox.where(sandboxed_id: self.id, sandboxed_type: self.class.name).destroy_all
-                    self.sandbox = nil
-                    self.save!
-                else
-                    unless self.sandbox.nil?
-                        self.sandbox.update_attributes environment: value
-                    else
-                        sandbox = self.build_sandbox
-                        sandbox.environment = value
-                        sandbox.save!
-                    end
-                end
-            end
-
-            def environment? value
-                self.environment == value
-            end
-
-            def environment
-                return Sandboxy.configuration.default if self.sandbox.nil?
-                self.sandbox.environment
-            end
-
-            private
-
-            def set_environment
-                unless Sandboxy.environment == Sandboxy.configuration.default
-                    sandbox = self.build_sandbox
-                    sandbox.environment = Sandboxy.environment
-                end
-            end
+    module SandboxyClassMethods
+      def method_missing(method, *args)
+        if method.to_s[/(.+)_environment/]
+          environment($1)
+        elsif method.to_s[/(.+)_environment_scoped/]
+          environment_scoped($1)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        super ||
+          method.to_s[/(.+)_environment/] ||
+          method.to_s[/(.+)_environment_scoped/]
+      end
+
+      def environment(value)
+        unscope(:joins, :where).environment_scoped value
+      end
+
+      def environment_scoped(value)
+        case value
+        when Sandboxy.configuration.default
+          left_outer_joins(:sandbox).where(sandboxy: { environment: nil })
+        else
+          left_outer_joins(:sandbox).where(sandboxy: { environment: value })
+        end
+      end
+    end
 
+    module SandboxyInstanceMethods
+      def method_missing(method, *args)
+        if method.to_s[/move_environment_(.+)/]
+          move_environment($1)
+        elsif method.to_s[/(.+)_environment?/]
+          environment?($1)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        super ||
+          method.to_s[/move_environment_(.+)/] ||
+          method.to_s[/(.+)_environment?/]
+      end
+
+      def move_environment(environment)
+        case environment
+        when Sandboxy.configuration.default
+          move_to_default_environment
+        else
+          move_to_custom_environment(environment)
         end
+      end
+
+      def environment?(value)
+        environment == value
+      end
+
+      def environment
+        return Sandboxy.configuration.default if sandbox.nil?
+
+        sandbox.environment
+      end
+
+      private
+
+      def set_environment
+        return if Sandboxy.environment == Sandboxy.configuration.default
+
+        sandbox = build_sandbox
+        sandbox.environment = Sandboxy.environment
+      end
+
+      def move_to_default_environment
+        Sandbox.where(sandboxed_id: id, sandboxed_type: self.class.name)
+               .destroy_all
+        self.sandbox = nil
+        save!
+      end
 
+      def move_to_custom_environment(environment)
+        sandbox ||= build_sandbox
+        sandbox.environment = environment
+        sandbox.save!
+      end
     end
+  end
 end

data/lib/sandboxy/version.rb

@@ -1,5 +1,5 @@
-module Sandboxy
-
-    VERSION = '3.0.0'
+# frozen_string_literal: true
 
+module Sandboxy
+  VERSION = '3.0.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sandboxy
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.0.1
 platform: ruby
 authors:
 - Jonas Hübotter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-29 00:00:00.000000000 Z
+date: 2019-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -25,75 +25,73 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: factory_bot
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: shoulda
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: factory_girl
+  name: shoulda
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.8'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.8'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: tzinfo-data
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2017'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2017'
-description: Sandboxy allows you to use virtual data-oriented environments inside
-  a Rails application while being able to switch in between at runtime. It achieves
-  that by using a combination of Rack Middleware and ActiveRecord.
-email: jonas.huebotter@gmail.com
+        version: '0'
+description: Sandboxy allows you to use virtualdata-oriented environments inside a
+  Railsapplication while being able to switch inbetween at runtime. It achieves that
+  by using acombination of Rack Middleware and ActiveRecord.
+email: me@jonhue.me
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- CHANGELOG.md
 - LICENSE
 - README.md
 - app/models/sandbox.rb
 - lib/generators/sandboxy_generator.rb
-- lib/generators/templates/README.md
 - lib/generators/templates/initializer.rb
 - lib/generators/templates/migration.rb.erb
 - lib/sandboxy.rb
@@ -107,10 +105,7 @@ homepage: https://github.com/jonhue/sandboxy
 licenses:
 - MIT
 metadata: {}
-post_install_message: |
-  **Thank you for installing Sandboxy!**
-  Get started by running `rails g sandboxy`.
-  Learn more at https://github.com/jonhue/sandboxy.
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -118,15 +113,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Virtual data-oriented environments for Rails

data/CHANGELOG.md

@@ -1,32 +0,0 @@
-# Changelog
-
-### master
-
-* nothing yet
-
-### 3.0.0 - 2017-12-29
-
-* features
-    * move `Sandbox` model into engine
-    * add support for multiple environments
-    * add `environment` attribute to `Sandbox` instances
-
-### 2.0.0 - 2017-12-21
-
-* features
-    * configuration by passing a block to `configure`
-    * generator generates initializer instead of yaml file
-
-### 1.1.1 - 2017-08-27
-
-* bugfixes
-    * fix undefined method `key` for `false`:Class
-
-### 1.1.0 - 2017-08-27
-
-* features
-    * use rack middleware to refresh environment defaults on new requests
-
-### 1.0.0 - 2017-08-27
-
-* initial release

data/lib/generators/templates/README.md

@@ -1 +0,0 @@
-Now run `rails db:migrate` to add sandboxy to your database.