microscope 0.3 → 0.4

data/README.md

@@ -1,6 +1,7 @@
 # Microscope
 
 [![Gem Version](https://badge.fury.io/rb/microscope.png)](https://rubygems.org/gems/microscope)
+[![Code Climate](https://codeclimate.com/github/mirego/microscope.png)](https://codeclimate.com/github/mirego/microscope)
 [![Build Status](https://travis-ci.org/mirego/microscope.png?branch=master)](https://travis-ci.org/mirego/microscope)
 
 Microscope adds useful scopes targeting ActiveRecord boolean, date and datetime fields.
@@ -61,6 +62,16 @@ Event.not_started
 # SELECT * FROM `events` where `events`.`started_at` IS NULL OR `events`.`started_at` > '2013-07-05 15:43:42'
 ```
 
+Microscope also adds two instance methods to the model per scope.
+
+```ruby
+event = Event.started.first
+# SELECT * FROM `events` where `events`.`started_at` IS NOT NULL AND `events`.`started_at` <= '2013-07-05 15:43:42' LIMIT 1
+
+event.started? # => true
+event.not_started? # => false
+```
+
 ### Options
 
 You can use a few options when calling `acts_as_microscope`:

data/lib/microscope/instance_method/date_instance_method.rb

@@ -0,0 +1,16 @@
+module Microscope
+  class InstanceMethod
+    class DateInstanceMethod < InstanceMethod
+      def apply
+        cropped_field = field.name.gsub(/_on$/, '')
+
+        model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          define_method "#{cropped_field}?" do
+            value = send("#{field.name}")
+            !value.nil? && value <= Date.today
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/microscope/instance_method/datetime_instance_method.rb

@@ -0,0 +1,16 @@
+module Microscope
+  class InstanceMethod
+    class DatetimeInstanceMethod < InstanceMethod
+      def apply
+        cropped_field = field.name.gsub(/_at$/, '')
+
+        model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          define_method "#{cropped_field}?" do
+            value = send("#{field.name}")
+            !value.nil? && value <= Time.now
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/microscope/instance_method.rb

@@ -0,0 +1,14 @@
+module Microscope
+  class InstanceMethod < Struct.new(:model, :field)
+    # Inject ActiveRecord scopes into a model
+    def self.inject_instance_methods(model, fields, options = {})
+      fields.each do |field|
+        scope = "#{field.type.to_s.camelize}InstanceMethod"
+
+        if Microscope::InstanceMethod.const_defined?(scope)
+          "Microscope::InstanceMethod::#{scope}".constantize.new(model, field).apply
+        end
+      end
+    end
+  end
+end

data/lib/microscope/scope/boolean_scope.rb

@@ -0,0 +1,12 @@
+module Microscope
+  class Scope
+    class BooleanScope < Scope
+      def apply
+        model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          scope "#{field.name}", lambda { where("#{field.name}" => true) }
+          scope "not_#{field.name}", lambda { where("#{field.name}" => false) }
+        RUBY
+      end
+    end
+  end
+end

data/lib/microscope/scope/date_scope.rb

@@ -0,0 +1,13 @@
+module Microscope
+  class Scope
+    class DateScope < DatetimeScope
+      def initialize(*args)
+        super
+
+        @now = 'Date.today'
+        @now_suffix = '_today'
+        @cropped_field_regex = /_on$/
+      end
+    end
+  end
+end

data/lib/microscope/scope/datetime_scope.rb

@@ -0,0 +1,55 @@
+module Microscope
+  class Scope
+    class DatetimeScope < Scope
+      def initialize(*args)
+        super
+
+        @now = 'Time.now'
+        @now_suffix = '_now'
+        @cropped_field_regex = /_at$/
+      end
+
+      def apply
+        @cropped_field = field.name.gsub(@cropped_field_regex, '')
+
+        model.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          #{before_scopes}
+          #{after_scopes}
+          #{between_scopes}
+          #{boolean_scopes}
+        RUBY
+      end
+
+    private
+
+      def before_scopes
+        <<-RUBY
+          scope "#{@cropped_field}_before", lambda { |time| where("#{field.name} < ?", time) }
+          scope "#{@cropped_field}_before_or_at", lambda { |time| where("#{field.name} <= ?", time) }
+          scope "#{@cropped_field}_before#{@now_suffix}", lambda { where("#{field.name} < ?", #{@now}) }
+        RUBY
+      end
+
+      def after_scopes
+        <<-RUBY
+          scope "#{@cropped_field}_after", lambda { |time| where("#{field.name} > ?", time) }
+          scope "#{@cropped_field}_after_or_at", lambda { |time| where("#{field.name} >= ?", time) }
+          scope "#{@cropped_field}_after#{@now_suffix}", lambda { where("#{field.name} > ?", #{@now}) }
+        RUBY
+      end
+
+      def between_scopes
+        <<-RUBY
+          scope "#{@cropped_field}_between", lambda { |range| where("#{field.name}" => range) }
+        RUBY
+      end
+
+      def boolean_scopes
+        <<-RUBY
+          scope "#{@cropped_field}", lambda { where("#{field.name} IS NOT NULL AND #{field.name} <= ?", #{@now}) }
+          scope "not_#{@cropped_field}", lambda { where("#{field.name} IS NULL OR #{field.name} > ?", #{@now}) }
+        RUBY
+      end
+    end
+  end
+end

data/lib/microscope/scope.rb

@@ -0,0 +1,14 @@
+module Microscope
+  class Scope < Struct.new(:model, :field)
+    # Inject ActiveRecord scopes into a model
+    def self.inject_scopes(model, fields, options = {})
+      fields.each do |field|
+        scope = "#{field.type.to_s.camelize}Scope"
+
+        if Microscope::Scope.const_defined?(scope)
+          "Microscope::Scope::#{scope}".constantize.new(model, field).apply
+        end
+      end
+    end
+  end
+end

data/lib/microscope/version.rb

@@ -1,3 +1,3 @@
 module Microscope
-  VERSION = "0.3"
+  VERSION = "0.4"
 end

data/lib/microscope.rb

@@ -3,17 +3,31 @@ require "microscope/version"
 require 'active_record'
 require 'active_support'
 
-require "microscope/mixin"
+require "microscope/scope"
+require "microscope/scope/boolean_scope"
+require "microscope/scope/datetime_scope"
+require "microscope/scope/date_scope"
+
+require "microscope/instance_method"
+require "microscope/instance_method/datetime_instance_method"
+require "microscope/instance_method/date_instance_method"
 
 module Microscope
   def self.inject_into_active_record
-    @inject_into_active_record ||= Proc.new do
+    Proc.new do
       def self.acts_as_microscope(options = {})
-        @microscope_options = options
-        include Microscope::Mixin
+        except = options[:except] || []
+        model_columns = columns.dup.reject { |c| except.include?(c.name.to_sym) }
+
+        if only = options[:only]
+          model_columns = model_columns.select { |c| only.include?(c.name.to_sym) }
+        end
+
+        Microscope::Scope.inject_scopes(self, model_columns, options)
+        Microscope::InstanceMethod.inject_instance_methods(self, model_columns, options)
       end
     end
   end
 end
 
-require 'microscope/railtie' if defined?(Rails) && Rails::VERSION::MAJOR >= 3
+ActiveRecord::Base.class_eval(&Microscope.inject_into_active_record)

data/spec/microscope/scope/boolean_scope_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Microscope::Scope::BooleanScope do
+  subject { User }
+
+  before do
+    run_migration do
+      create_table(:users, force: true) do |t|
+        t.boolean :active, default: false
+      end
+    end
+
+    microscope 'User'
+  end
+
+  describe 'positive scope' do
+    before { @user1 = User.create(active: true) }
+
+    its(:active) { should have(1).items }
+    its(:active) { should include(@user1) }
+    its(:not_active) { should be_empty }
+  end
+
+  describe 'negative scope' do
+    before { @user1 = User.create(active: false) }
+
+    its(:not_active) { should have(1).items }
+    its(:not_active) { should include(@user1) }
+    its(:active) { should be_empty }
+  end
+end

data/spec/microscope/scope/date_scope_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Microscope::Scope::DateScope do
+  subject { Event }
+
+  before do
+    run_migration do
+      create_table(:events, force: true) do |t|
+        t.date :started_on, default: nil
+      end
+    end
+
+    microscope 'Event'
+  end
+
+  describe 'before scope' do
+    before do
+      @event = Event.create(started_on: 2.months.ago)
+      Event.create(started_on: 1.month.from_now)
+    end
+
+    it { expect(Event.started_before(1.month.ago).to_a).to eql [@event] }
+  end
+
+  describe 'before_today scope' do
+    before do
+      @event = Event.create(started_on: 2.months.ago)
+      Event.create(started_on: 1.month.from_now)
+    end
+
+    it { expect(Event.started_before_today.to_a).to eql [@event] }
+  end
+
+  describe 'after scope' do
+    before do
+      @event = Event.create(started_on: 2.months.from_now)
+      Event.create(started_on: 1.month.ago)
+    end
+
+    it { expect(Event.started_after(1.month.from_now).to_a).to eql [@event] }
+  end
+
+  describe 'after_today scope' do
+    before do
+      @event = Event.create(started_on: 2.months.from_now)
+      Event.create(started_on: 1.month.ago)
+    end
+
+    it { expect(Event.started_after_today.to_a).to eql [@event] }
+  end
+
+  describe 'between scope' do
+    before do
+      Event.create(started_on: 1.month.ago)
+      @event = Event.create(started_on: 3.months.ago)
+      Event.create(started_on: 5.month.ago)
+    end
+
+    it { expect(Event.started_between(4.months.ago..2.months.ago).to_a).to eql [@event] }
+  end
+
+  describe 'super-boolean positive scope' do
+    before do
+      @event1 = Event.create(started_on: 1.month.ago)
+      @event2 = Event.create(started_on: 3.months.ago)
+      Event.create(started_on: 2.months.from_now)
+      Event.create(started_on: nil)
+    end
+
+    it { expect(Event.started.to_a).to eql [@event1, @event2] }
+  end
+
+  describe 'super-boolean negative scope' do
+    before do
+      Event.create(started_on: 1.month.ago)
+      Event.create(started_on: 3.months.ago)
+      @event1 = Event.create(started_on: 2.months.from_now)
+      @event2 = Event.create(started_on: nil)
+    end
+
+    it { expect(Event.not_started.to_a).to eql [@event1, @event2] }
+  end
+
+  describe 'boolean instance method' do
+    context 'for positive record' do
+      subject { Event.create(started_on: 3.months.ago) }
+      it { should be_started }
+    end
+
+    context 'for negative record' do
+      subject { Event.create(started_on: 2.months.from_now) }
+      it { should_not be_started }
+    end
+  end
+end

data/spec/microscope/scope/datetime_scope_spec.rb

@@ -0,0 +1,93 @@
+describe Microscope::Scope::DatetimeScope do
+  subject { Event }
+
+  before do
+    run_migration do
+      create_table(:events, force: true) do |t|
+        t.datetime :started_at, default: nil
+      end
+    end
+
+    microscope 'Event'
+  end
+
+  describe 'before scope' do
+    before do
+      @event = Event.create(started_at: 2.months.ago)
+      Event.create(started_at: 1.month.from_now)
+    end
+
+    it { expect(Event.started_before(1.month.ago).to_a).to eql [@event] }
+  end
+
+  describe 'before_now scope' do
+    before do
+      @event = Event.create(started_at: 2.months.ago)
+      Event.create(started_at: 1.month.from_now)
+    end
+
+    it { expect(Event.started_before_now.to_a).to eql [@event] }
+  end
+
+  describe 'after scope' do
+    before do
+      @event = Event.create(started_at: 2.months.from_now)
+      Event.create(started_at: 1.month.ago)
+    end
+
+    it { expect(Event.started_after(1.month.from_now).to_a).to eql [@event] }
+  end
+
+  describe 'after_now scope' do
+    before do
+      @event = Event.create(started_at: 2.months.from_now)
+      Event.create(started_at: 1.month.ago)
+    end
+
+    it { expect(Event.started_after_now.to_a).to eql [@event] }
+  end
+
+  describe 'between scope' do
+    before do
+      Event.create(started_at: 1.month.ago)
+      @event = Event.create(started_at: 3.months.ago)
+      Event.create(started_at: 5.month.ago)
+    end
+
+    it { expect(Event.started_between(4.months.ago..2.months.ago).to_a).to eql [@event] }
+  end
+
+  describe 'super-boolean positive scope', focus: true do
+    before do
+      @event1 = Event.create(started_at: 1.month.ago)
+      @event2 = Event.create(started_at: 3.months.ago)
+      Event.create(started_at: 2.months.from_now)
+      Event.create(started_at: nil)
+    end
+
+    it { expect(Event.started.to_a).to eql [@event1, @event2] }
+  end
+
+  describe 'super-boolean negative scope' do
+    before do
+      Event.create(started_at: 1.month.ago)
+      Event.create(started_at: 3.months.ago)
+      @event1 = Event.create(started_at: 2.months.from_now)
+      @event2 = Event.create(started_at: nil)
+    end
+
+    it { expect(Event.not_started.to_a).to eql [@event1, @event2] }
+  end
+
+  describe 'boolean instance method' do
+    context 'for positive record' do
+      subject { Event.create(started_at: 3.months.ago) }
+      it { should be_started }
+    end
+
+    context 'for negative record' do
+      subject { Event.create(started_at: 2.months.from_now) }
+      it { should_not be_started }
+    end
+  end
+end

data/spec/microscope/scope_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Microscope::Scope do
+  describe :inject_scopes do
+    subject { User }
+
+    before do
+      run_migration do
+        create_table(:users, force: true) do |t|
+          t.boolean :active, default: false
+          t.boolean :admin, default: false
+          t.boolean :moderator, default: false
+        end
+      end
+    end
+
+    describe :except do
+      before do
+        microscope 'User', except: [:admin]
+      end
+
+      it { should respond_to :active }
+      it { should respond_to :not_active }
+      it { should respond_to :moderator }
+      it { should respond_to :not_moderator }
+      it { should_not respond_to :admin }
+      it { should_not respond_to :not_admin }
+    end
+
+    describe :only do
+      before do
+        microscope 'User', only: [:admin]
+      end
+
+      it { should_not respond_to :active }
+      it { should_not respond_to :not_active }
+      it { should_not respond_to :moderator }
+      it { should_not respond_to :not_moderator }
+      it { should respond_to :admin }
+      it { should respond_to :not_admin }
+    end
+
+    describe 'except and only' do
+      before do
+        microscope 'User', only: [:admin], except: [:active]
+      end
+
+      it { should_not respond_to :active }
+      it { should_not respond_to :not_active }
+      it { should_not respond_to :moderator }
+      it { should_not respond_to :not_moderator }
+      it { should respond_to :admin }
+      it { should respond_to :not_admin }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -8,9 +8,6 @@ require 'microscope'
 # Require our macros and extensions
 Dir[File.expand_path('../../spec/support/macros/*.rb', __FILE__)].map(&method(:require))
 
-# Inject our methods into ActiveRecord (like our railtie does)
-ActiveRecord::Base.class_eval(&Microscope.inject_into_active_record)
-
 RSpec.configure do |config|
   # Include our macros
   config.include DatabaseMacros

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: microscope
 version: !ruby/object:Gem::Version
-  version: '0.3'
+  version: '0.4'
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-08 00:00:00.000000000 Z
+date: 2013-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -127,11 +127,19 @@ files:
 - gemfiles/Gemfile.activerecord-3.2.x
 - gemfiles/Gemfile.activerecord-4.0
 - lib/microscope.rb
-- lib/microscope/mixin.rb
-- lib/microscope/railtie.rb
+- lib/microscope/instance_method.rb
+- lib/microscope/instance_method/date_instance_method.rb
+- lib/microscope/instance_method/datetime_instance_method.rb
+- lib/microscope/scope.rb
+- lib/microscope/scope/boolean_scope.rb
+- lib/microscope/scope/date_scope.rb
+- lib/microscope/scope/datetime_scope.rb
 - lib/microscope/version.rb
 - microscope.gemspec
-- spec/microscope/mixin_spec.rb
+- spec/microscope/scope/boolean_scope_spec.rb
+- spec/microscope/scope/date_scope_spec.rb
+- spec/microscope/scope/datetime_scope_spec.rb
+- spec/microscope/scope_spec.rb
 - spec/spec_helper.rb
 - spec/support/macros/database_macros.rb
 - spec/support/macros/model_macros.rb
@@ -150,7 +158,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1281633982724090897
+      hash: 2193329954126245792
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -159,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1281633982724090897
+      hash: 2193329954126245792
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -168,7 +176,10 @@ specification_version: 3
 summary: Microscope adds useful scopes targeting ActiveRecord boolean and datetime
   fields.
 test_files:
-- spec/microscope/mixin_spec.rb
+- spec/microscope/scope/boolean_scope_spec.rb
+- spec/microscope/scope/date_scope_spec.rb
+- spec/microscope/scope/datetime_scope_spec.rb
+- spec/microscope/scope_spec.rb
 - spec/spec_helper.rb
 - spec/support/macros/database_macros.rb
 - spec/support/macros/model_macros.rb

data/lib/microscope/mixin.rb

@@ -1,62 +0,0 @@
-module Microscope
-  module Mixin
-    extend ActiveSupport::Concern
-
-    included do
-      define_microscrope_scopes
-    end
-
-    module ClassMethods
-      def define_microscrope_scopes
-        except = @microscope_options[:except] || []
-        model_columns = self.columns.dup.reject { |c| except.include?(c.name.to_sym) }
-
-        if only = @microscope_options[:only]
-          model_columns = model_columns.select { |c| only.include?(c.name.to_sym) }
-        end
-
-        boolean_fields = model_columns.select { |c| c.type == :boolean }.map(&:name)
-        boolean_fields.each do |field|
-          scope field, lambda { where(field => true) }
-          scope "not_#{field}", lambda { where(field => false) }
-        end
-
-        datetime_fields = model_columns.select { |c| c.type == :datetime }.map(&:name)
-        datetime_fields.each do |field|
-          cropped_field = field.gsub(/_at$/, '')
-
-          scope "#{cropped_field}_before", lambda { |time| where("#{field} < ?", time) }
-          scope "#{cropped_field}_before_or_at", lambda { |time| where("#{field} <= ?", time) }
-          scope "#{cropped_field}_before_now", lambda { where("#{field} < ?", Time.now) }
-
-          scope "#{cropped_field}_after", lambda { |time| where("#{field} > ?", time) }
-          scope "#{cropped_field}_after_or_at", lambda { |time| where("#{field} >= ?", time) }
-          scope "#{cropped_field}_after_now", lambda { where("#{field} > ?", Time.now) }
-
-          scope "#{cropped_field}_between", lambda { |range| where(field => range) }
-
-          scope "#{cropped_field}", lambda { where("#{field} IS NOT NULL AND #{field} <= ?", Time.now) }
-          scope "not_#{cropped_field}", lambda { where("#{field} IS NULL OR #{field} > ?", Time.now) }
-        end
-
-        date_fields = model_columns.select { |c| c.type == :date }.map(&:name)
-        date_fields.each do |field|
-          cropped_field = field.gsub(/_on$/, '')
-
-          scope "#{cropped_field}_before", lambda { |time| where("#{field} < ?", time) }
-          scope "#{cropped_field}_before_or_on", lambda { |time| where("#{field} <= ?", time) }
-          scope "#{cropped_field}_before_today", lambda { where("#{field} < ?", Date.today) }
-
-          scope "#{cropped_field}_after", lambda { |time| where("#{field} > ?", time) }
-          scope "#{cropped_field}_after_or_at", lambda { |time| where("#{field} >= ?", time) }
-          scope "#{cropped_field}_after_today", lambda { where("#{field} > ?", Date.today) }
-
-          scope "#{cropped_field}_between", lambda { |range| where(field => range) }
-
-          scope "#{cropped_field}", lambda { where("#{field} IS NOT NULL AND #{field} <= ?", Date.today) }
-          scope "not_#{cropped_field}", lambda { where("#{field} IS NULL OR #{field} > ?", Date.today) }
-        end
-      end
-    end
-  end
-end

data/lib/microscope/railtie.rb

@@ -1,10 +0,0 @@
-require 'microscope'
-require 'rails'
-
-module Microscope
-  class Railtie < Rails::Railtie
-    initializer 'microscope.active_record' do |app|
-      ActiveSupport.on_load :active_record, {}, &Microscope.inject_into_active_record
-    end
-  end
-end

data/spec/microscope/mixin_spec.rb

@@ -1,250 +0,0 @@
-require 'spec_helper'
-
-describe Microscope::Mixin do
-  describe :acts_as_microscope do
-    subject { User }
-
-    before do
-      run_migration do
-        create_table(:users, force: true) do |t|
-          t.boolean :active, default: false
-          t.boolean :admin, default: false
-          t.boolean :moderator, default: false
-        end
-      end
-    end
-
-    describe :except do
-      before do
-        microscope 'User', except: [:admin]
-      end
-
-      it { should respond_to :active }
-      it { should respond_to :not_active }
-      it { should respond_to :moderator }
-      it { should respond_to :not_moderator }
-      it { should_not respond_to :admin }
-      it { should_not respond_to :not_admin }
-    end
-
-    describe :only do
-      before do
-        microscope 'User', only: [:admin]
-      end
-
-      it { should_not respond_to :active }
-      it { should_not respond_to :not_active }
-      it { should_not respond_to :moderator }
-      it { should_not respond_to :not_moderator }
-      it { should respond_to :admin }
-      it { should respond_to :not_admin }
-    end
-
-    describe 'except and only' do
-      before do
-        microscope 'User', only: [:admin], except: [:active]
-      end
-
-      it { should_not respond_to :active }
-      it { should_not respond_to :not_active }
-      it { should_not respond_to :moderator }
-      it { should_not respond_to :not_moderator }
-      it { should respond_to :admin }
-      it { should respond_to :not_admin }
-    end
-  end
-
-  describe 'Boolean scopes' do
-    subject { User }
-
-    before do
-      run_migration do
-        create_table(:users, force: true) do |t|
-          t.boolean :active, default: false
-        end
-      end
-
-      microscope 'User'
-    end
-
-    describe 'positive scope' do
-      before { @user1 = User.create(active: true) }
-
-      its(:active) { should have(1).items }
-      its(:active) { should include(@user1) }
-      its(:not_active) { should be_empty }
-    end
-
-    describe 'negative scope' do
-      before { @user1 = User.create(active: false) }
-
-      its(:not_active) { should have(1).items }
-      its(:not_active) { should include(@user1) }
-      its(:active) { should be_empty }
-    end
-  end
-
-  describe 'DateTime scopes' do
-    subject { Event }
-
-    before do
-      run_migration do
-        create_table(:events, force: true) do |t|
-          t.datetime :started_at, default: nil
-        end
-      end
-
-      microscope 'Event'
-    end
-
-    describe 'before scope' do
-      before do
-        @event = Event.create(started_at: 2.months.ago)
-        Event.create(started_at: 1.month.from_now)
-      end
-
-      it { expect(Event.started_before(1.month.ago).to_a).to eql [@event] }
-    end
-
-    describe 'before_now scope' do
-      before do
-        @event = Event.create(started_at: 2.months.ago)
-        Event.create(started_at: 1.month.from_now)
-      end
-
-      it { expect(Event.started_before_now.to_a).to eql [@event] }
-    end
-
-    describe 'after scope' do
-      before do
-        @event = Event.create(started_at: 2.months.from_now)
-        Event.create(started_at: 1.month.ago)
-      end
-
-      it { expect(Event.started_after(1.month.from_now).to_a).to eql [@event] }
-    end
-
-    describe 'after_now scope' do
-      before do
-        @event = Event.create(started_at: 2.months.from_now)
-        Event.create(started_at: 1.month.ago)
-      end
-
-      it { expect(Event.started_after_now.to_a).to eql [@event] }
-    end
-
-    describe 'between scope' do
-      before do
-        Event.create(started_at: 1.month.ago)
-        @event = Event.create(started_at: 3.months.ago)
-        Event.create(started_at: 5.month.ago)
-      end
-
-      it { expect(Event.started_between(4.months.ago..2.months.ago).to_a).to eql [@event] }
-    end
-
-    describe 'super-boolean positive scope', focus: true do
-      before do
-        @event1 = Event.create(started_at: 1.month.ago)
-        @event2 = Event.create(started_at: 3.months.ago)
-        Event.create(started_at: 2.months.from_now)
-        Event.create(started_at: nil)
-      end
-
-      it { expect(Event.started.to_a).to eql [@event1, @event2] }
-    end
-
-    describe 'super-boolean negative scope' do
-      before do
-        Event.create(started_at: 1.month.ago)
-        Event.create(started_at: 3.months.ago)
-        @event1 = Event.create(started_at: 2.months.from_now)
-        @event2 = Event.create(started_at: nil)
-      end
-
-      it { expect(Event.not_started.to_a).to eql [@event1, @event2] }
-    end
-  end
-
-  describe 'Date scopes' do
-    subject { Event }
-
-    before do
-      run_migration do
-        create_table(:events, force: true) do |t|
-          t.date :started_on, default: nil
-        end
-      end
-
-      microscope 'Event'
-    end
-
-    describe 'before scope' do
-      before do
-        @event = Event.create(started_on: 2.months.ago)
-        Event.create(started_on: 1.month.from_now)
-      end
-
-      it { expect(Event.started_before(1.month.ago).to_a).to eql [@event] }
-    end
-
-    describe 'before_today scope' do
-      before do
-        @event = Event.create(started_on: 2.months.ago)
-        Event.create(started_on: 1.month.from_now)
-      end
-
-      it { expect(Event.started_before_today.to_a).to eql [@event] }
-    end
-
-    describe 'after scope' do
-      before do
-        @event = Event.create(started_on: 2.months.from_now)
-        Event.create(started_on: 1.month.ago)
-      end
-
-      it { expect(Event.started_after(1.month.from_now).to_a).to eql [@event] }
-    end
-
-    describe 'after_today scope' do
-      before do
-        @event = Event.create(started_on: 2.months.from_now)
-        Event.create(started_on: 1.month.ago)
-      end
-
-      it { expect(Event.started_after_today.to_a).to eql [@event] }
-    end
-
-    describe 'between scope' do
-      before do
-        Event.create(started_on: 1.month.ago)
-        @event = Event.create(started_on: 3.months.ago)
-        Event.create(started_on: 5.month.ago)
-      end
-
-      it { expect(Event.started_between(4.months.ago..2.months.ago).to_a).to eql [@event] }
-    end
-
-    describe 'super-boolean positive scope' do
-      before do
-        @event1 = Event.create(started_on: 1.month.ago)
-        @event2 = Event.create(started_on: 3.months.ago)
-        Event.create(started_on: 2.months.from_now)
-        Event.create(started_on: nil)
-      end
-
-      it { expect(Event.started.to_a).to eql [@event1, @event2] }
-    end
-
-    describe 'super-boolean negative scope' do
-      before do
-        Event.create(started_on: 1.month.ago)
-        Event.create(started_on: 3.months.ago)
-        @event1 = Event.create(started_on: 2.months.from_now)
-        @event2 = Event.create(started_on: nil)
-      end
-
-      it { expect(Event.not_started.to_a).to eql [@event1, @event2] }
-    end
-  end
-end