consul 1.3.1 → 2.0.0

data/Gemfile.8-0.lock

@@ -0,0 +1,174 @@
+PATH
+  remote: .
+  specs:
+    consul (2.0.0)
+      activerecord (>= 6.0)
+      activesupport (>= 6.0)
+      edge_rider (>= 0.3.0)
+      memoized (>= 1.0.2)
+      railties (>= 6.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (8.0.1)
+      actionview (= 8.0.1)
+      activesupport (= 8.0.1)
+      nokogiri (>= 1.8.5)
+      rack (>= 2.2.4)
+      rack-session (>= 1.0.1)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+      useragent (~> 0.16)
+    actionview (8.0.1)
+      activesupport (= 8.0.1)
+      builder (~> 3.1)
+      erubi (~> 1.11)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+    activemodel (8.0.1)
+      activesupport (= 8.0.1)
+    activerecord (8.0.1)
+      activemodel (= 8.0.1)
+      activesupport (= 8.0.1)
+      timeout (>= 0.4.0)
+    activesupport (8.0.1)
+      base64
+      benchmark (>= 0.3)
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      logger (>= 1.4.2)
+      minitest (>= 5.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    assignable_values (1.0.0)
+      activerecord (>= 2.3)
+    base64 (0.2.0)
+    benchmark (0.4.0)
+    bigdecimal (3.1.8)
+    builder (3.3.0)
+    concurrent-ruby (1.3.3)
+    connection_pool (2.4.1)
+    crass (1.0.6)
+    database_cleaner (2.0.2)
+      database_cleaner-active_record (>= 2, < 3)
+    database_cleaner-active_record (2.2.0)
+      activerecord (>= 5.a)
+      database_cleaner-core (~> 2.0.0)
+    database_cleaner-core (2.0.1)
+    date (3.4.1)
+    diff-lcs (1.5.1)
+    drb (2.2.1)
+    edge_rider (2.3.0)
+      activerecord (>= 3.2)
+    erubi (1.13.0)
+    gemika (0.8.3)
+    i18n (1.14.5)
+      concurrent-ruby (~> 1.0)
+    io-console (0.8.0)
+    irb (1.14.3)
+      rdoc (>= 4.0.0)
+      reline (>= 0.4.2)
+    logger (1.6.1)
+    loofah (2.22.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.12.0)
+    memoized (1.1.1)
+    mini_portile2 (2.8.8)
+    minitest (5.24.1)
+    nokogiri (1.16.6)
+      mini_portile2 (~> 2.8.2)
+      racc (~> 1.4)
+    psych (5.2.2)
+      date
+      stringio
+    racc (1.8.0)
+    rack (3.1.7)
+    rack-session (2.0.0)
+      rack (>= 3.0.0)
+    rack-test (2.1.0)
+      rack (>= 1.3)
+    rackup (2.2.1)
+      rack (>= 3)
+    rails-dom-testing (2.2.0)
+      activesupport (>= 5.0.0)
+      minitest
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.6.0)
+      loofah (~> 2.21)
+      nokogiri (~> 1.14)
+    railties (8.0.1)
+      actionpack (= 8.0.1)
+      activesupport (= 8.0.1)
+      irb (~> 1.13)
+      rackup (>= 1.0.0)
+      rake (>= 12.2)
+      thor (~> 1.0, >= 1.2.2)
+      zeitwerk (~> 2.6)
+    rake (13.2.1)
+    rdoc (6.10.0)
+      psych (>= 4.0.0)
+    reline (0.6.0)
+      io-console (~> 0.5)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.0)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-rails (6.1.3)
+      actionpack (>= 6.1)
+      activesupport (>= 6.1)
+      railties (>= 6.1)
+      rspec-core (~> 3.13)
+      rspec-expectations (~> 3.13)
+      rspec-mocks (~> 3.13)
+      rspec-support (~> 3.13)
+    rspec-support (3.13.1)
+    rspec_candy (0.5.1)
+      rspec
+      sneaky-save
+    securerandom (0.3.2)
+    shoulda-matchers (6.2.0)
+      activesupport (>= 5.2.0)
+    sneaky-save (0.1.3)
+      activerecord (>= 3.2.0)
+    sqlite3 (2.4.1)
+      mini_portile2 (~> 2.8.0)
+    stringio (3.1.2)
+    thor (1.3.2)
+    timeout (0.4.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    uri (1.0.2)
+    useragent (0.16.10)
+    zeitwerk (2.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  assignable_values
+  consul!
+  database_cleaner
+  gemika (>= 0.8.1)
+  railties (~> 8.0)
+  rspec
+  rspec-rails
+  rspec_candy
+  shoulda-matchers
+  sqlite3
+
+BUNDLED WITH
+   2.5.15

data/Gemfile.lock

@@ -1 +1 @@
-Gemfile.7-0.lock
+Gemfile.8-0.lock

data/README.md

@@ -1,19 +1,29 @@
-Consul — A next gen authorization solution
-==========================================
-
-[![Tests](https://github.com/makandra/consul/workflows/Tests/badge.svg)](https://github.com/makandra/consul/actions) [![Code Climate](https://codeclimate.com/github/makandra/consul.png)](https://codeclimate.com/github/makandra/consul)
-
-
-Consul is an authorization solution for Ruby on Rails where you describe *sets of accessible things* to control what a user can see or edit.
+<p>
+  <a href="https://makandra.de/">
+    <picture>
+      <source media="(prefers-color-scheme: light)" srcset="media/makandra-with-bottom-margin.light.svg">
+      <source media="(prefers-color-scheme: dark)" srcset="media/makandra-with-bottom-margin.dark.svg">
+      <img align="right" width="25%" alt="makandra" src="media/makandra-with-bottom-margin.light.svg">
+    </picture>
+  </a>
+
+  <picture>
+    <source media="(prefers-color-scheme: light)" srcset="media/logo.light.shapes.svg">
+    <source media="(prefers-color-scheme: dark)" srcset="media/logo.dark.shapes.svg">
+    <img width="155" alt="consul" role="heading" aria-level="1" src="media/logo.light.shapes.svg">
+  </picture>
+</p>
+
+[![Tests](https://github.com/makandra/consul/workflows/Tests/badge.svg)](https://github.com/makandra/consul/actions)
+
+Consul is an authorization solution for Ruby on Rails where you describe _sets of accessible things_ to control what a user can see or edit.
 
 We have used Consul in combination with [assignable_values](https://github.com/makandra/assignable_values) to solve a variety of authorization requirements ranging from boring to bizarre.
 Also see our crash course video: [Solving bizare authorization requirements with Rails](http://bizarre-authorization.talks.makandra.com/).
 
-Consul is tested with Rails 5.2, 6.1 and 7.0 on Ruby 2.5, 2.7 and 3.0 (only if supported, for each Ruby/Rails combination). If you need support for Rails 3.2, please use [v0.13.2](https://github.com/makandra/consul/tree/v0.13.2).
+Consul is tested with Rails 6.1, 7.1, 7.2 and 8.0 on Ruby 2.5, 2.7, 3.2, 3.3 (only if supported, for each Ruby/Rails combination). If you need support for Rails 3.2, please use [v0.13.2](https://github.com/makandra/consul/tree/v0.13.2).
 
-
-Describing access to your application
--------------------------------------
+## Describing access to your application
 
 You describe access to your application by putting a `Power` model into `app/models/power.rb`.
 Inside your `Power` you can talk about what is accessible for the current user, e.g.
@@ -51,10 +61,8 @@ There are no restrictions on the name or constructor arguments of this class.
 
 You can deposit all kinds of objects in your power. See the sections below for details.
 
-
 ### Scope powers (relations)
 
-
 A typical use case in a Rails application is to restrict access to your ActiveRecord models. For example:
 
 - Anonymous visitors may only see public posts
@@ -111,13 +119,10 @@ power.note!(Note.last) # => raises Consul::Powerless unless the given Note is in
 
 See our crash course video [Solving bizare authorization requirements with Rails](http://bizarre-authorization.talks.makandra.com/) for many different use cases you can cover with this pattern.
 
-
-
 ### Defining different powers for different actions
 
 If you have different access rights for e.g. viewing or updating posts, simply use different powers:
 
-
 ```rb
 class Power
   ...
@@ -139,8 +144,6 @@ end
 
 There is also a [shortcut to map different powers to RESTful controller actions](#protect-entry-into-controller-actions).
 
-
-
 ### Boolean powers
 
 Boolean powers are useful to control access to stuff that doesn't live in the database:
@@ -164,7 +167,6 @@ power.dashboard? # => true
 power.dashboard! # => raises Consul::Powerless unless Power#dashboard? returns true
 ```
 
-
 ### Powers that give no access at all
 
 Note that there is a difference between having access to an empty list of records, and having no access at all.
@@ -194,8 +196,6 @@ power.user?(User.last) # => returns false
 power.user!(User.last) # => raises Consul::Powerless
 ```
 
-
-
 ### Powers that only check a given object
 
 Sometimes it is not convenient to define powers as a collection or scope (relation).
@@ -203,7 +203,6 @@ Sometimes you only want to store a method that checks whether a given object is
 
 To do so, simply define a power that ends in a question mark:
 
-
 ```rb
 class Power
   ...
@@ -223,7 +222,6 @@ power.updatable_post?(Post.last) # return true if the author of the post is @use
 power.updatable_post!(Post.last) # raises Consul::Powerless unless the author of the post is @user
 ```
 
-
 ### Other types of powers
 
 A power can return any type of object. For instance, you often want to return an array:
@@ -254,7 +252,6 @@ power.assignable_note_state?('published') # => returns false
 power.assignable_note_state!('published') # => raises Consul::Powerless
 ```
 
-
 ### Defining multiple powers at once
 
 You can define multiple powers at once by giving multiple power names:
@@ -270,7 +267,6 @@ class Power
 end
 ```
 
-
 ### Powers that require context (arguments)
 
 Sometimes it can be useful to define powers that require context. To do so, just take an argument in your `power` block:
@@ -294,7 +290,6 @@ note = ...
 Power.current.client_note?(client, note)
 ```
 
-
 ### Optimizing record checks for scope powers
 
 You can query a scope power for a given record, e.g.
@@ -337,9 +332,7 @@ end
 
 This way you do not need to touch the database at all.
 
-
-Role-based permissions
-----------------------
+## Role-based permissions
 
 Consul has no built-in support for role-based permissions, but you can easily implement it yourself. Let's say your `User` model has a string column `role` which can be `"author"` or `"admin"`:
 
@@ -367,9 +360,7 @@ class Power
 end
 ```
 
-
-Controller integration
-----------------------
+## Controller integration
 
 It is convenient to expose the power for the current request to the rest of the application. Consul will help you with that if you tell it how to instantiate a power for the current request:
 
@@ -398,7 +389,6 @@ class NotesController < ApplicationController
 end
 ```
 
-
 ### Protect entry into controller actions
 
 To make sure a power is given before every action in a controller:
@@ -409,7 +399,7 @@ class NotesController < ApplicationController
 end
 ```
 
-You can use `:except` and `:only` options like in before\_actions.
+You can use `:except` and `:only` options like in before_actions.
 
 You can also map different powers to different actions:
 
@@ -441,7 +431,6 @@ class NotesController < ApplicationController
 end
 ```
 
-
 And if your power [requires context](#powers-that-require-context-arguments) (is parametrized), you can give it using the `:context` method:
 
 ```rb
@@ -458,8 +447,6 @@ class ClientNotesController < ApplicationController
 end
 ```
 
-
-
 ### Auto-mapping a power scope to a controller method
 
 It is often convenient to map a power scope to a private controller method:
@@ -486,7 +473,7 @@ class NotesController < ApplicationController
   power :notes, :as => :note_scope
 
   # ...
-    
+
   def note_scope
     super.where(trashed: false)
   end
@@ -494,7 +481,6 @@ class NotesController < ApplicationController
 end
 ```
 
-
 ### Multiple power-mappings for nested resources
 
 When using [nested resources](http://guides.rubyonrails.org/routing.html#nested-resources) you probably want two power
@@ -564,7 +550,7 @@ class ApplicationController < ActionController::Base
 end
 ```
 
-Note that this check is satisfied by *any* `.power` directive in the controller class or its ancestors, even if that `.power` directive has `:only` or `:except` options that do not apply to the current action.
+Note that this check is satisfied by _any_ `.power` directive in the controller class or its ancestors, even if that `.power` directive has `:only` or `:except` options that do not apply to the current action.
 
 Should you want to forego the power check (e.g. to remove authorization checks from an entirely public controller):
 
@@ -574,9 +560,7 @@ class ApiController < ApplicationController
 end
 ```
 
-
-Validating assignable values
-----------------------------
+## Validating assignable values
 
 Sometimes a scope is not enough to express what a user can edit. You will often want to give a user write access to a record, but restrict the values she can assign to a given field.
 
@@ -647,8 +631,7 @@ The `authorize_values_for` macro comes with many useful options and details best
 assignable_values_for :field, :through => lambda { Power.current }
 ```
 
-Memoization
------------
+## Memoization
 
 All power methods are [memoized](https://www.justinweiss.com/articles/4-simple-memoization-patterns-in-ruby-and-one-gem/) for performance reasons. Multiple calls to the same method will only call your block the first time, and return a cached result afterwards:
 
@@ -665,9 +648,7 @@ If you want to discard all cached results, call `#unmemoize_all`:
 power.unmemoize_all
 ```
 
-
-Dynamic power access
---------------------
+## Dynamic power access
 
 Consul gives you a way to dynamically access and query powers for a given name, model class or record.
 A common use case for this are generic helper methods, e.g. a method to display an "edit" link for any given record
@@ -687,30 +668,27 @@ end
 
 You can find a full list of available dynamic calls below:
 
-| Dynamic call                                            | Equivalent                                 |
-|---------------------------------------------------------|--------------------------------------------|
-| `Power.current.send(:notes)`                            | `Power.current.notes`                      |
-| `Power.current.include_power?(:notes)`                  | `Power.current.notes?`                     |
-| `Power.current.include_power!(:notes)`                  | `Power.current.notes!`                     |
-| `Power.current.include_object?(:notes, Note.last)`      | `Power.current.note?(Note.last)`           |
-| `Power.current.include_object!(:notes, Note.last)`      | `Power.current.note!(Note.last)`           |
-| `Power.current.for_model(Note)`                         | `Power.current.notes`                      |
-| `Power.current.for_model(:updatable, Note)`             | `Power.current.updatable_notes`            |
-| `Power.current.include_model?(Note)`                    | `Power.current.notes?`                     |
-| `Power.current.include_model?(:updatable, Note)`        | `Power.current.updatable_notes?`           |
-| `Power.current.include_model!(Note)`                    | `Power.current.notes!`                     |
-| `Power.current.include_model!(:updatable, Note)`        | `Power.current.updatable_notes!`           |
-| `Power.current.include_record?(Note.last)`              | `Power.current.note?(Note.last)`           |
-| `Power.current.include_record?(:updatable, Note.last)`  | `Power.current.updatable_note?(Note.last)` |
-| `Power.current.include_record!(Note.last)`              | `Power.current.note!(Note.last)`           |
-| `Power.current.include_record!(:updatable, Note.last)`  | `Power.current.updatable_note!(Note.last)` |
-| `Power.current.name_for_model(Note)`                    | `:notes`                                   |
-| `Power.current.name_for_model(:updatable, Note)`        | `:updatable_notes`                         |
-
-
-
-Querying a power that might be nil
-----------------------------------
+| Dynamic call                                           | Equivalent                                 |
+| ------------------------------------------------------ | ------------------------------------------ |
+| `Power.current.send(:notes)`                           | `Power.current.notes`                      |
+| `Power.current.include_power?(:notes)`                 | `Power.current.notes?`                     |
+| `Power.current.include_power!(:notes)`                 | `Power.current.notes!`                     |
+| `Power.current.include_object?(:notes, Note.last)`     | `Power.current.note?(Note.last)`           |
+| `Power.current.include_object!(:notes, Note.last)`     | `Power.current.note!(Note.last)`           |
+| `Power.current.for_model(Note)`                        | `Power.current.notes`                      |
+| `Power.current.for_model(:updatable, Note)`            | `Power.current.updatable_notes`            |
+| `Power.current.include_model?(Note)`                   | `Power.current.notes?`                     |
+| `Power.current.include_model?(:updatable, Note)`       | `Power.current.updatable_notes?`           |
+| `Power.current.include_model!(Note)`                   | `Power.current.notes!`                     |
+| `Power.current.include_model!(:updatable, Note)`       | `Power.current.updatable_notes!`           |
+| `Power.current.include_record?(Note.last)`             | `Power.current.note?(Note.last)`           |
+| `Power.current.include_record?(:updatable, Note.last)` | `Power.current.updatable_note?(Note.last)` |
+| `Power.current.include_record!(Note.last)`             | `Power.current.note!(Note.last)`           |
+| `Power.current.include_record!(:updatable, Note.last)` | `Power.current.updatable_note!(Note.last)` |
+| `Power.current.name_for_model(Note)`                   | `:notes`                                   |
+| `Power.current.name_for_model(:updatable, Note)`       | `:updatable_notes`                         |
+
+## Querying a power that might be nil
 
 You will often want to access `Power.current` from another model, to e.g. iterate through the list of accessible users:
 
@@ -760,23 +738,20 @@ end
 
 There is a long selection of class methods that behave neutrally in case `Power.current` is `nil`:
 
-| Call                                                     | Equivalent                                                          |
-|----------------------------------------------------------|---------------------------------------------------------------------|
-| `Power.for_model(Note)`                                  | `Power.current.present? ? Power.current.notes : Note`               |
-| `Power.for_model(:updatable, Note)`                      | `Power.current.present? ? Power.current.updatable_notes : Note`     |
-| `Power.include_model?(Note)`                             | `Power.current.present? ? Power.notes? : true`                      |
-| `Power.include_model?(:updatable, Note)`                 | `Power.current.present? ? Power.updatable_notes? : true`            |
-| `Power.include_model!(Note)`                             | `Power.notes! if Power.current.present?`                            |
-| `Power.include_model!(:updatable, Note)`                 | `Power.updatable_notes! if Power.current.present?`                  |
-| `Power.include_record?(Note.last)`                       | `Power.current.present? ? Power.note?(Note.last) : true`            |
-| `Power.include_record?(:updatable, Note.last)`           | `Power.current.present? ? Power.updatable_note?(Note.last?) : true` |
-| `Power.include_record!(Note.last)`                       | `Power.note!(Note.last) if Power.current.present?`                  |
-| `Power.include_record!(:updatable, Note.last)`           | `Power.updatable_note!(Note.last) if Power.current.present?`        |
-
-
-
-Testing
--------
+| Call                                           | Equivalent                                                          |
+| ---------------------------------------------- | ------------------------------------------------------------------- |
+| `Power.for_model(Note)`                        | `Power.current.present? ? Power.current.notes : Note`               |
+| `Power.for_model(:updatable, Note)`            | `Power.current.present? ? Power.current.updatable_notes : Note`     |
+| `Power.include_model?(Note)`                   | `Power.current.present? ? Power.notes? : true`                      |
+| `Power.include_model?(:updatable, Note)`       | `Power.current.present? ? Power.updatable_notes? : true`            |
+| `Power.include_model!(Note)`                   | `Power.notes! if Power.current.present?`                            |
+| `Power.include_model!(:updatable, Note)`       | `Power.updatable_notes! if Power.current.present?`                  |
+| `Power.include_record?(Note.last)`             | `Power.current.present? ? Power.note?(Note.last) : true`            |
+| `Power.include_record?(:updatable, Note.last)` | `Power.current.present? ? Power.updatable_note?(Note.last?) : true` |
+| `Power.include_record!(Note.last)`             | `Power.note!(Note.last) if Power.current.present?`                  |
+| `Power.include_record!(:updatable, Note.last)` | `Power.updatable_note!(Note.last) if Power.current.present?`        |
+
+## Testing
 
 This section Some hints for testing authorization with Consul.
 
@@ -847,9 +822,7 @@ Power.without_power do
 end
 ```
 
-
-Installation
-------------
+## Installation
 
 Add the following to your `Gemfile`:
 
@@ -859,15 +832,13 @@ gem 'consul'
 
 Now run `bundle install` to lock the gem into your project.
 
+## Development
 
-Development
------------
-
-We currently develop using Ruby 2.5.3 (see `.ruby-version`) since that version works for current versions of ActiveRecord that we support. GitHub Actions will test additional Ruby versions (2.3.8, 2.4.5, and 3.0.1).
+We currently develop using Ruby 3.4.1 (see `.ruby-version`) since that version works for current versions of ActiveRecord that we support. GitHub Actions will test additional Ruby versions (2.7.3, 3.2.0).
 
 There are tests in `spec`. We only accept PRs with tests. To run tests:
 
-- Install Ruby 2.5.3
+- Install Ruby 3.4.1
 - run `bundle install`
 - Put your database credentials into `spec/support/database.yml`. There's a `database.sample.yml` you can use as a template.
 - There are gem bundles in the project root for each rails version that we support.
@@ -884,8 +855,6 @@ Note that we have configured GitHub Actions to automatically run tests in all su
 
 I'm very eager to keep this gem leightweight and on topic. If you're unsure whether a change would make it into the gem, [talk to me beforehand](mailto:henning.koch@makandra.de).
 
-
-Credits
--------
+## Credits
 
 Henning Koch from [makandra](http://makandra.com/)

data/consul.gemspec

@@ -26,8 +26,8 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_dependency('memoized', '>=1.0.2')
-  s.add_dependency('activerecord', '>= 3.2')
-  s.add_dependency('activesupport', '>= 3.2')
-  s.add_dependency('railties', '>= 3.2')
+  s.add_dependency('activerecord', '>= 6.0')
+  s.add_dependency('activesupport', '>= 6.0')
+  s.add_dependency('railties', '>= 6.0')
   s.add_dependency('edge_rider', '>= 0.3.0')
 end

data/lib/consul/active_record.rb

@@ -14,4 +14,6 @@ module Consul
   end
 end
 
-ActiveRecord::Base.send(:extend, Consul::ActiveRecord)
+ActiveSupport.on_load(:active_record) do
+  extend(Consul::ActiveRecord)
+end

data/lib/consul/util.rb

@@ -3,11 +3,7 @@ module Consul
     extend self
 
     def scope_selects_all_records?(scope)
-      if Rails.version.to_i < 3
-        scope = scope.scoped({})
-      else
-        scope = scope.scoped
-      end
+      scope = scope.scoped
       scope_sql = scope.to_sql
       quoted_table_name = Regexp.quote(scope.connection.quote_table_name(scope.table_name))
       all_sql_pattern = /\ASELECT (#{quoted_table_name}\.)?\* FROM #{quoted_table_name}\z/
@@ -23,26 +19,17 @@ module Consul
     end
 
     def define_scope(klass, name, lambda)
-      if Rails.version.to_i < 4 # Rails 2/3
-        scope_definition = Rails.version.to_i < 3 ? :named_scope : :scope
-        klass.send scope_definition, name, lambda
-      else
-        klass.send :scope, name, lambda { |*args|
-          options = lambda.call(*args)
-          klass.scoped(options.slice *EdgeRider::Scoped::VALID_FIND_OPTIONS)
-        }
-      end
+      klass.send :scope, name, lambda { |*args|
+        options = lambda.call(*args)
+        klass.scoped(options.slice *EdgeRider::Scoped::VALID_FIND_OPTIONS)
+      }
     end
 
     # This method does not support dynamic default scopes via lambdas
     # (as does #define_scope), because it is currently not required.
     def define_default_scope(klass, conditions)
-      if Rails.version.to_i < 4 # Rails 2/3
-        klass.send :default_scope, conditions
-      else
-        klass.send :default_scope do
-          klass.scoped(conditions)
-        end
+      klass.send :default_scope do
+        klass.scoped(conditions)
       end
     end
 
@@ -58,33 +45,19 @@ module Consul
     end
 
     def skip_before_action(controller_class, name, options)
-      if Rails.version.to_i < 4
-        controller_class.skip_before_filter name, options
-      elsif Rails.version.to_i < 5
-        controller_class.skip_before_action name, options
-      else
-        # Every `power` in a controller will skip the power check filter. After the 1st time, Rails 5+ will raise
-        # an error because there is no `unchecked_power` action to skip any more.
-        # To avoid this, we add the following extra option. Note that it must not be added in Rails 4 to avoid errors.
-        # See http://api.rubyonrails.org/classes/ActiveSupport/Callbacks/ClassMethods.html#method-i-skip_callback
-        controller_class.skip_before_action name, { :raise => false }.merge!(options)
-      end
+      # Every `power` in a controller will skip the power check filter. After the 1st time, Rails will raise
+      # an error because there is no `unchecked_power` action to skip any more.
+      # To avoid this, we add the following extra option.
+      # See http://api.rubyonrails.org/classes/ActiveSupport/Callbacks/ClassMethods.html#method-i-skip_callback
+      controller_class.skip_before_action name, { :raise => false }.merge!(options)
     end
 
     def before_action(controller_class, *args, &block)
-      if Rails.version.to_i < 4
-        controller_class.before_filter *args, &block
-      else
-        controller_class.before_action *args, &block
-      end
+      controller_class.before_action *args, &block
     end
 
     def around_action(controller_class, *args, &block)
-      if Rails.version.to_i < 4
-        controller_class.around_filter *args, &block
-      else
-        controller_class.around_action *args, &block
-      end
+      controller_class.around_action *args, &block
     end
 
   end

data/lib/consul/version.rb

@@ -1,3 +1,3 @@
 module Consul
-  VERSION = '1.3.1'
+  VERSION = '2.0.0'
 end