sandboxy 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5eac48d43fcaf454f691ca0169d9ba357f31e46b30aa452e4de0d99f172e9a7
-  data.tar.gz: 61eeb91dfcd1b788cd95b4f8944684b792552e1f378b46c910eb46e8b2a454a0
+  metadata.gz: 179b0c17257a3a969fee06ad285d9e832a5f4b90adfbeb3e1b8bd2c8eef0a45b
+  data.tar.gz: e6eb6c261f8abee9fb55c15c4d51ccd284953ecfc3727397eaaf1519f1fed29b
 SHA512:
-  metadata.gz: be725877526b7a6e616670c73a0ea5348a0feee76e05d600ad4aa404e04d64b5e1dce0dcb17a2aadadcd692235e3ac09a6f7ad942b51abe652ce17ec3890d1ec
-  data.tar.gz: 51d58e7689ffef821e4d44a71be4aea455b3e19976c58c963caa1c968789754f25f12eb4f4dcaffe0bd46cc00ba80fb043aca9665c88939bb4d7babae4333e5d
+  metadata.gz: 43b75cf5aa42131b4bca6ae0d9c2b3bfaa90d6b88453de2d75401b6c28a27da69b8589f6cbebdd55dba68ddcdb9e7f79acd1f4704a6826f4f15905505e7a8436
+  data.tar.gz: 050d0c42b7b47bffbc1161b38d184ba315d7bbd2431fefb5efc53dea25d1a25fb0923937cec88bdbd83e74b888b2a021a2308399ca8a5218d3c943fc2bbd5ba9

data/CHANGELOG.md

@@ -4,6 +4,13 @@
 
 * 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

data/README.md

@@ -12,7 +12,6 @@ Sandboxy allows you to use virtual data-oriented environments inside a Rails app
 * [Usage](#usage)
     * [Setup](#setup)
     * [`sandboxy` methods](#sandboxy-methods)
-    * [Sandboxy class methods](#sandboxy-class-methods)
     * [Switching environments](#switching-environments)
         * [Sandbox & APIs](#sandbox--apis)
 * [Configuration](#configuration)
@@ -28,7 +27,7 @@ Sandboxy allows you to use virtual data-oriented environments inside a Rails app
 
 ## Installation
 
-Sandboxy works with Rails 5.0 onwards. You can add it to your `Gemfile` with:
+Sandboxy works with Rails 5 onwards. You can add it to your `Gemfile` with:
 
 ```ruby
 gem 'sandboxy'
@@ -60,7 +59,7 @@ To wrap things up, migrate the changes into your database:
 
 ### Setup
 
-Add Sandboxy to the models where you want to separate live & sandbox records:
+Add Sandboxy to the models where you want to separate records depending on their environments:
 
 ```ruby
 class Foo < ApplicationRecord
@@ -72,6 +71,7 @@ In most use cases you would want to add `sandboxy` to a lot of ActiveRecord mode
 
 ```ruby
 class SharedSandbox < ApplicationRecord
+    self.abstract_class = true
     sandboxy
 end
 
@@ -81,18 +81,20 @@ end
 
 ### `sandboxy` methods
 
-By default you can only access records belonging to the current environment (`live` or `sandbox`):
+By default you can only access records belonging to the current environment (defined by `Sandboxy.environment`):
 
 ```ruby
-$sandbox = true
+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 group regardless of your current environment, you can use:
+Now to access the records belonging to a certain environment regardless of your current environment, you can use:
 
 ```ruby
-Foo.live # => returns all live foo's
-Foo.sandboxed # => returns all sandbox foo's
+Foo.live_environment # => returns all live foo's
+Foo.sandbox_environment # => returns all sandbox foo's
 Foo.desandbox # => returns all foo's
 ```
 
@@ -100,8 +102,8 @@ Let's check to which environment this `Foo` belongs:
 
 ```ruby
 foo = Foo.create!
-foo.live? # => false
-foo.sandboxed? # => true
+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.
@@ -109,41 +111,29 @@ You should keep in mind that when you create a new record, it will automatically
 Don't worry, you can move records between environments:
 
 ```ruby
-foo.make_live
-foo.live? # => true
-foo.make_sandboxed
-foo.sandboxed? # => true
+foo.move_environment_live
+foo.live_environment? # => true
+foo.move_environment_sandbox
+foo.sandbox_environment? # => true
 ```
 
-### `Sandboxy` class methods
-
-To access your default environment setting:
-
-```ruby
-Sandboxy.configuration.environment # => 'live' / 'sandbox'
-Sandboxy.configuration.sandbox? # => true / false
-Sandboxy.configuration.live? # => true / false
-```
-
-**Note:** `Sandboxy.configuration.environment` does *NOT* return the apps current environment. For that use the [`$sandbox` variable](#switching-environments) instead.
+### Switching environments
 
-You can also access whether your app retains your environment throughout requests:
+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.configuration.retain_environment # => true / false
+Sandboxy.environment = 'live'
+Sandboxy.live_environment? # => true
+Sandboxy.sandbox_environment? # => true
 ```
 
-### Switching environments
-
-At runtime you can always switch environments by using the `$sandbox` variable anywhere in your application. Set it to `true` to enable the `sandbox` environment. Set it to `false` to enable the `live` environment. That makes Sandboxy super flexible.
-
 #### 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 the `$sandbox` variable 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.
+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.
 
 ---
 
@@ -153,13 +143,13 @@ You can configure Sandboxy by passing a block to `configure`. This can be done i
 
 ```ruby
 Sandboxy.configure do |config|
-    config.environment = 'sandbox'
+    config.default = 'sandbox'
 end
 ```
 
-**`environment`** Set your environment default: Must be either `live` or `sandbox`. This is the environment that your app boots with. By default it gets refreshed with every new request to your server. Defaults to `'live'`.
+**`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_environment`** Specify whether to retain your current app environment on new requests. If set to `true`, your app will only load your environment default when starting. Every additional switch of your environment at runtime will then not be automatically resolved to your environment default on a new request. Takes a boolean. Defaults to `false`.
+**`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`.
 
 ---
 
@@ -181,7 +171,7 @@ Tests are written with Shoulda on top of `Test::Unit` with Factory Girl being us
 
 Test coverage can be calculated using SimpleCov. Make sure you have the [simplecov gem](https://github.com/colszowka/simplecov) installed.
 
-1. Uncomment SimpleCov in the Gemfile
+1. Add SimpleCov to the Gemfile
 2. Uncomment the relevant section in `test/test_helper.rb`
 3. Run tests
 

data/{examples/rails_example/app → app}/models/sandbox.rb

@@ -1,4 +1,4 @@
-class Sandbox < ActiveRecord::Base
+class Sandbox < ApplicationRecord
 
     self.table_name = 'sandboxy'
 

data/lib/generators/sandboxy_generator.rb

@@ -24,10 +24,6 @@ class SandboxyGenerator < Rails::Generators::Base
         migration_template 'migration.rb.erb', 'db/migrate/sandboxy_migration.rb', migration_version: migration_version
     end
 
-    def create_model
-        template 'model.rb', 'app/models/sandbox.rb'
-    end
-
     def show_readme
         readme 'README.md'
     end

data/lib/generators/templates/initializer.rb

@@ -1,13 +1,13 @@
 Sandboxy.configure do |config|
 
-    # Set your environment default: Must be either `live` or `sandbox`.
-    # This is the environment that your app boots with.
+    # 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.
-    # config.environment = 'live'
+    # Takes a string.
+    # config.default = 'live'
 
-    # Specify whether to retain your current app environment on new requests.
-    # If set to true, your app will only load your environment default when starting.
-    # Every additional switch of your environment at runtime will then not be automatically resolved to your environment default on a new request.
-    # config.retain_environment = false
+    # 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,14 +1,9 @@
 class SandboxyMigration < ActiveRecord::Migration<%= migration_version %>
-    def self.up
-        create_table :sandboxy, force: true do |t|
-            t.references :sandboxed, polymorphic: true, null: false
+    def change
+        create_table :sandboxy do |t|
+            t.references :sandboxed, polymorphic: true, index: true
+            t.string :environment, index: true
             t.timestamps
         end
-
-        add_index :sandboxy, ['sandboxed_id', 'sandboxed_type'], name: 'sandboxy_sandboxed'
-    end
-
-    def self.down
-        drop_table :sandboxy
     end
 end

data/lib/sandboxy.rb

@@ -2,16 +2,9 @@ require 'sandboxy/version'
 
 module Sandboxy
 
-    autoload :Configuration, 'sandboxy/configuration'
+    require 'sandboxy/configuration'
 
-    class << self
-        attr_accessor :configuration
-    end
-
-    def self.configure
-        self.configuration ||= Configuration.new
-        yield configuration
-    end
+    require 'sandboxy/engine'
 
     autoload :Sandboxed, 'sandboxy/sandboxed'
 

data/lib/sandboxy/configuration.rb

@@ -1,20 +1,47 @@
 module Sandboxy
-    class Configuration
 
-        attr_accessor :environment
-        attr_accessor :retain_environment
+    class << self
+        attr_accessor :configuration
 
-        def initialize
-            @environment = 'live'
-            @retain_environment = false
+        def environment
+            $sandboxy ||= Sandboxy.configuration.default
+            $sandboxy
+        end
+
+        def environment= value
+            $sandboxy = value
         end
 
-        def sandbox?
-            self.environment == 'sandbox' ? true : false
+        def method_missing m, *args
+            if m.to_s[/(.+)_environment?/]
+                self.environment? $1
+            else
+                super
+            end
         end
 
-        def live?
-            !self.sandbox?
+        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

data/lib/sandboxy/engine.rb

@@ -0,0 +1,6 @@
+require 'rails/railtie'
+
+module Sandboxy
+    class Engine < ::Rails::Engine
+    end
+end

data/lib/sandboxy/middleware.rb

@@ -8,10 +8,10 @@ module Sandboxy
         def call env
             require 'sandboxy'
 
-            previous_sandbox = $sandbox
-            $sandbox = Sandboxy.configuration.environment == 'sandbox' ? true : false
+            previous_environment = Sandboxy.environment
+            $sandboxy = nil
 
-            puts 'Sandbox: Moved to ' + Sandboxy.configuration.environment.to_s + ' environment' if $sandbox != previous_sandbox
+            puts "Sandboxy: Moved to #{Sandboxy.configuration.default} environment" if Sandboxy.environment != previous_environment
         end
 
     end

data/lib/sandboxy/railtie.rb

@@ -1,4 +1,5 @@
-require 'rails'
+require 'rails/railtie'
+require 'active_record'
 
 
 module Sandboxy
@@ -10,12 +11,12 @@ module Sandboxy
             end
         end
 
-        initializer 'sandboxy.configure_rails_initialization' do |app|
-            require 'sandboxy'
-            puts 'Sandboxy: Using ' + Sandboxy.configuration.environment + ' environment'
+        initializer 'sandboxy.middleware' do |app|
+            app.middleware.use(Sandboxy::Middleware) unless Sandboxy.configuration&.retain
+        end
 
-            $sandbox = Sandboxy.configuration.environment == 'sandbox' ? true : false
-            app.middleware.use(Sandboxy::Middleware) unless Sandboxy.configuration.retain_environment
+        config.after_initialize do
+            puts "Sandboxy: Using #{Sandboxy.configuration.default} environment"
         end
 
     end

data/lib/sandboxy/sandboxed.rb

@@ -9,41 +9,91 @@ module Sandboxy
 
             def sandboxy
                 has_one :sandbox, as: :sandboxed, dependent: :destroy
+                before_create :set_environment
                 include Sandboxy::Sandboxed::InstanceMethods
 
-                scope :live_scoped, -> { left_outer_joins(:sandbox).where(sandbox: { id: nil }) }
-                scope :sandboxed_scoped, -> { left_outer_joins(:sandbox).where.not(sandbox: { id: nil }) }
-                default_scope {
-                    case $sandbox
-                    when true then sandboxed_scoped
-                    when false then live_scoped
-                    end
-                }
-                scope :live, -> { unscope(:joins, :where).live_scoped }
-                scope :sandboxed, -> { unscope(:joins, :where).sandboxed_scoped }
+                default_scope { self.environment_scoped(Sandboxy.environment) }
                 scope :desandbox, -> { unscope(:joins, :where).all }
 
-                # before_save :make_sandboxed # -> should be handled automatically through default_scope
+                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
 
         end
 
         module InstanceMethods
 
-            def make_sandboxed
-                self.build_sandbox unless self.sandbox.present?
+            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 make_live
-                self.sandbox.destroy if self.sandbox.present?
+            def respond_to? m, include_private = false
+                super || m.to_s[/move_environment_(.+)/] || m.to_s[/(.+)_environment?/]
             end
 
-            def sandboxed?
-                self.sandbox.present?
+            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 live?
-                !self.sandboxed?
+            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
 
         end