activerecord_views 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d730fc5ba86879e6e1a74f23f1e3320809d37e8d
-  data.tar.gz: dc5a5b0e4453124be60b9ed57178fd81f763617d
+  metadata.gz: ad72d8911d4f996a5b7eb841d2a7b1f930d16aac
+  data.tar.gz: 1891b3ee70bfa4e3737213f285b2e350c9c628ae
 SHA512:
-  metadata.gz: 5281382c91bde1d07a1784d781d6c618c14e059201c3d252e1d1490bd47bd2fc52890134b715430f5a29f8ae6bbbb5ac9916d9d2d6e7f3ffc7f452cf94442a53
-  data.tar.gz: 1286c8ea11028e69b5c4e850600d1b8899672e80ee5618648e98c37fc7ec9864ddc2476e3d2dd926f0a77dfc7f65f37c2c59a486fca008e0b09c2a4fb507a7bb
+  metadata.gz: dda606e695a85d2e07170c2337d315d72a23cab5e0c53650035168d520e8ebfd9661a8e78a1025a46f9c556fd080eb9da07c1101343d614bae12ca97ce209988
+  data.tar.gz: b84c8e82443bf416f9c754ecba2a097ed002bf7b97c2c8a24c90049e6f4984e8f3ba7626ebef7e33cc41d968401a219b1d54bcb0755ca6c2272341c9ed9ed23d

data/README.markdown

@@ -68,6 +68,35 @@ Account.includes(:account_balance).find_each do |account|
 end
 ```
 
+## Dependencies
+
+You can use an view model from another view model or within SQL blocks in your application code.
+In order to ensure the model file is loaded (and thus the view is created), you should reference
+the model class when you use the view rather than using the database table name directly:
+
+```ruby
+connection.select_values <<-SQL
+  SELECT …
+  FROM …
+  INNER JOIN #{AccountBalance.table_name} … # use instead of account_balances
+  …
+SQL
+```
+
+Due to the importance of ensuring view models load in the correct order, ActiveRecordViews has
+a safety check which will require you to specify the dependency explicitly if your view refers
+to another view model:
+
+```ruby
+class AccountBalance < ActiveRecord::Base
+  is_view
+end
+
+class AccountSummary < ActiveRecord::Base
+  is_view dependencies: [AccountBalance]
+end
+```
+
 ## Materialized views
 
 ActiveRecordViews has support [PostgreSQL's materialized views](http://www.postgresql.org/docs/9.4/static/rules-materializedviews.html).
@@ -128,6 +157,12 @@ In order to keep things tidy and to avoid accidentally referencing a stale view,
 ActiveRecordViews.drop_view connection, 'account_balances'
 ```
 
+Alternatively, all view models can be dropped with the following:
+
+```ruby
+ActiveRecordViews.drop_all_views connection
+```
+
 ## Usage outside of Rails
 
 When included in a Ruby on Rails project, ActiveRecordViews will automatically detect `.sql` files alongside models in `app/models`.

data/lib/active_record_views.rb

@@ -54,7 +54,9 @@ module ActiveRecordViews
   end
 
   def self.create_view(base_connection, name, class_name, sql, options = {})
-    options.assert_valid_keys :materialized, :unique_columns
+    options = options.dup
+    options.assert_valid_keys :dependencies, :materialized, :unique_columns
+    options[:dependencies] = parse_dependencies(options[:dependencies])
 
     without_transaction base_connection do |connection|
       cache = ActiveRecordViews::ChecksumCache.new(connection)
@@ -66,7 +68,10 @@ module ActiveRecordViews
       else
         raise ArgumentError, 'unique_columns option requires view to be materialized' if options[:unique_columns]
         begin
-          connection.execute "CREATE OR REPLACE VIEW #{connection.quote_table_name name} AS #{sql}"
+          connection.transaction :requires_new => true do
+            connection.execute "CREATE OR REPLACE VIEW #{connection.quote_table_name name} AS #{sql}"
+            check_dependencies connection, name, class_name, options[:dependencies]
+          end
           false
         rescue ActiveRecord::StatementInvalid
           true
@@ -75,9 +80,10 @@ module ActiveRecordViews
 
       if drop_and_create
         connection.transaction :requires_new => true do
-          without_dependencies connection, name do
+          without_dependants connection, name do
             execute_drop_view connection, name
             execute_create_view connection, name, sql, options
+            check_dependencies connection, name, class_name, options[:dependencies]
           end
         end
       end
@@ -86,6 +92,43 @@ module ActiveRecordViews
     end
   end
 
+  def self.parse_dependencies(dependencies)
+    dependencies = Array(dependencies)
+    unless dependencies.all? { |dependency| dependency.is_a?(Class) && dependency < ActiveRecord::Base }
+      raise ArgumentError, 'dependencies must be ActiveRecord classes'
+    end
+    dependencies.map(&:name).sort
+  end
+
+  def self.check_dependencies(connection, name, class_name, declared_class_names)
+    actual_class_names = get_view_direct_dependencies(connection, name).sort
+
+    missing_class_names = actual_class_names - declared_class_names
+    extra_class_names = declared_class_names - actual_class_names
+
+    if missing_class_names.present?
+      example = "is_view dependencies: [#{actual_class_names.join(', ')}]"
+      raise ArgumentError, <<-TEXT.squish
+        #{missing_class_names.to_sentence}
+        must be specified as
+        #{missing_class_names.size > 1 ? 'dependencies' : 'a dependency'}
+        of #{class_name}:
+        `#{example}`
+      TEXT
+    end
+
+    if extra_class_names.present?
+      raise ArgumentError, <<-TEXT.squish
+        #{extra_class_names.to_sentence}
+        #{extra_class_names.size > 1 ? 'are' : 'is'}
+        not
+        #{extra_class_names.size > 1 ? 'dependencies' : 'a dependency'}
+        of
+        #{class_name}
+      TEXT
+    end
+  end
+
   def self.drop_view(base_connection, name)
     without_transaction base_connection do |connection|
       cache = ActiveRecordViews::ChecksumCache.new(connection)
@@ -94,8 +137,23 @@ module ActiveRecordViews
     end
   end
 
+  def self.drop_all_views(connection)
+    names = Set.new connection.select_values('SELECT name FROM active_record_views;')
+
+    func = lambda do |name|
+      if view_exists?(connection, name)
+        get_view_dependants(connection, name).each do |dependant_name, _, _, _|
+          func.call(dependant_name)
+        end
+        drop_view connection, name
+      end
+    end
+
+    names.each { |name| func.call(name) }
+  end
+
   def self.execute_create_view(connection, name, sql, options)
-    options.assert_valid_keys :materialized, :unique_columns
+    options.assert_valid_keys :dependencies, :materialized, :unique_columns
     sql = sql.sub(/;\s*\z/, '')
 
     if options[:materialized]
@@ -146,7 +204,26 @@ module ActiveRecordViews
     connection.raw_connection.server_version >= 90400
   end
 
-  def self.get_view_dependencies(connection, name)
+  def self.get_view_direct_dependencies(connection, name)
+    connection.select_values <<-SQL.squish
+      WITH dependencies AS (
+        SELECT DISTINCT refobjid::regclass::text AS name
+        FROM pg_depend d
+        INNER JOIN pg_rewrite r ON r.oid = d.objid
+        WHERE refclassid = 'pg_class'::regclass
+        AND classid = 'pg_rewrite'::regclass
+        AND deptype = 'n'
+        AND refobjid != r.ev_class
+        AND r.ev_class = #{connection.quote name}::regclass::oid
+      )
+
+      SELECT class_name
+      FROM dependencies
+      INNER JOIN active_record_views USING (name)
+    SQL
+  end
+
+  def self.get_view_dependants(connection, name)
     connection.select_rows <<-SQL.squish
       WITH RECURSIVE dependants AS (
         SELECT
@@ -178,30 +255,30 @@ module ActiveRecordViews
     SQL
   end
 
-  def self.without_dependencies(connection, name)
+  def self.without_dependants(connection, name)
     unless view_exists?(connection, name)
       yield
       return
     end
 
-    dependencies = get_view_dependencies(connection, name)
+    dependants = get_view_dependants(connection, name)
     cache = ActiveRecordViews::ChecksumCache.new(connection)
-    dependency_metadata = {}
+    dependant_metadata = {}
 
-    dependencies.reverse.each do |dependency_name, _, _, _|
-      execute_drop_view connection, dependency_name
-      dependency_metadata[dependency_name] = cache.get(dependency_name)
-      cache.set dependency_name, nil
+    dependants.reverse.each do |dependant_name, _, _, _|
+      execute_drop_view connection, dependant_name
+      dependant_metadata[dependant_name] = cache.get(dependant_name)
+      cache.set dependant_name, nil
     end
 
     yield
 
-    dependencies.each do |dependency_name, class_name, definition, options_json|
+    dependants.each do |dependant_name, class_name, definition, options_json|
       create_view_exception = begin
         connection.transaction :requires_new => true do
           options = JSON.load(options_json).symbolize_keys
-          execute_create_view connection, dependency_name, definition, options
-          cache.set dependency_name, dependency_metadata[dependency_name]
+          execute_create_view connection, dependant_name, definition, options
+          cache.set dependant_name, dependant_metadata[dependant_name]
         end
         nil
       rescue StandardError => e

data/lib/active_record_views/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordViews
-  VERSION = '0.0.9'
+  VERSION = '0.0.10'
 end

data/spec/active_record_views_extension_spec.rb

@@ -91,24 +91,30 @@ describe ActiveRecordViews::Extension do
     end
 
     it 'successfully recreates modified paired views with incompatible changes' do
-      ActiveRecordViews.create_view ActiveRecord::Base.connection, 'modified_as', 'ModifiedA', 'SELECT 11 AS old_name;'
-      ActiveRecordViews.create_view ActiveRecord::Base.connection, 'modified_bs', 'ModifiedB', 'SELECT old_name FROM modified_as;'
+      without_dependency_checks do
+        ActiveRecordViews.create_view ActiveRecord::Base.connection, 'modified_as', 'ModifiedA', 'SELECT 11 AS old_name;'
+        ActiveRecordViews.create_view ActiveRecord::Base.connection, 'modified_bs', 'ModifiedB', 'SELECT old_name FROM modified_as;'
+      end
 
       expect(ModifiedB.first.attributes.except(nil)).to eq('new_name' => 22)
     end
 
     it 'successfully restores dependant view when temporarily dropping dependency' do
-      ActiveRecordViews.create_view ActiveRecord::Base.connection, 'dependency_as', 'DependencyA', 'SELECT 42 AS foo, 1 AS id;'
-      ActiveRecordViews.create_view ActiveRecord::Base.connection, 'dependency_bs', 'DependencyB', 'SELECT id FROM dependency_as;'
+      without_dependency_checks do
+        ActiveRecordViews.create_view ActiveRecord::Base.connection, 'dependency_as', 'DependencyA', 'SELECT 42 AS foo, 1 AS id;'
+        ActiveRecordViews.create_view ActiveRecord::Base.connection, 'dependency_bs', 'DependencyB', 'SELECT id FROM dependency_as;'
+      end
 
       expect(DependencyA.first.id).to eq 2
       expect(DependencyB.first.id).to eq 2
     end
 
     it 'sucessfully restore dependant view and dependency when loading from middle outwards' do
-      ActiveRecordViews.create_view ActiveRecord::Base.connection, 'dependency_as', 'DependencyA', 'SELECT 42 AS foo, 1 AS id;'
-      ActiveRecordViews.create_view ActiveRecord::Base.connection, 'dependency_bs', 'DependencyB', 'SELECT id FROM dependency_as;'
-      ActiveRecordViews.create_view ActiveRecord::Base.connection, 'dependency_cs', 'DependencyC', 'SELECT id FROM dependency_bs;'
+      without_dependency_checks do
+        ActiveRecordViews.create_view ActiveRecord::Base.connection, 'dependency_as', 'DependencyA', 'SELECT 42 AS foo, 1 AS id;'
+        ActiveRecordViews.create_view ActiveRecord::Base.connection, 'dependency_bs', 'DependencyB', 'SELECT id FROM dependency_as;'
+        ActiveRecordViews.create_view ActiveRecord::Base.connection, 'dependency_cs', 'DependencyC', 'SELECT id FROM dependency_bs;'
+      end
 
       expect(DependencyB.first.id).to eq 2
     end
@@ -204,5 +210,74 @@ describe ActiveRecordViews::Extension do
         MaterializedViewAutoRefreshTestModel.refresh_view! concurrent: :blah
       }.to raise_error ArgumentError, 'invalid concurrent option'
     end
+
+    it 'errors if dependencies are not specified' do
+      class DependencyCheckBase1 < ActiveRecord::Base
+        self.table_name = 'dependency_check_base1'
+        is_view 'SELECT 1 AS ID;'
+      end
+      class DependencyCheckBase2 < ActiveRecord::Base
+        self.table_name = 'dependency_check_base2'
+        is_view 'SELECT 1 AS ID;'
+      end
+      ActiveRecord::Base.connection.execute 'CREATE VIEW dependency_check_base_unmanaged AS SELECT 1 AS ID;'
+
+      expect {
+        class DependencyCheckGood < ActiveRecord::Base
+          is_view 'SELECT * FROM dependency_check_base1;', dependencies: [DependencyCheckBase1]
+        end
+      }.to_not raise_error
+
+      expect {
+        class DependencyCheckGoodUnmanaged < ActiveRecord::Base
+          is_view 'SELECT * FROM dependency_check_base_unmanaged;'
+        end
+      }.to_not raise_error
+
+      expect {
+        class DependencyCheckMissing1 < ActiveRecord::Base
+          is_view 'SELECT * FROM dependency_check_base1 UNION ALL SELECT * FROM dependency_check_base2;', dependencies: [DependencyCheckBase1]
+        end
+      }.to raise_error ArgumentError, 'DependencyCheckBase2 must be specified as a dependency of DependencyCheckMissing1: `is_view dependencies: [DependencyCheckBase1, DependencyCheckBase2]`'
+
+      expect {
+        class DependencyCheckMissing2 < ActiveRecord::Base
+          is_view 'SELECT * FROM dependency_check_base1 UNION ALL SELECT * FROM dependency_check_base2;', dependencies: []
+        end
+      }.to raise_error ArgumentError, 'DependencyCheckBase1 and DependencyCheckBase2 must be specified as dependencies of DependencyCheckMissing2: `is_view dependencies: [DependencyCheckBase1, DependencyCheckBase2]`'
+
+      expect {
+        class DependencyCheckNested < ActiveRecord::Base
+          is_view 'SELECT 1 FROM dependency_check_goods'
+        end
+      }.to raise_error ArgumentError, 'DependencyCheckGood must be specified as a dependency of DependencyCheckNested: `is_view dependencies: [DependencyCheckGood]`'
+
+      expect {
+        class DependencyCheckExtra1 < ActiveRecord::Base
+          is_view 'SELECT * FROM dependency_check_base1;', dependencies: [DependencyCheckBase1, DependencyCheckBase2]
+        end
+      }.to raise_error ArgumentError, 'DependencyCheckBase2 is not a dependency of DependencyCheckExtra1'
+
+      expect {
+        class DependencyCheckExtra2 < ActiveRecord::Base
+          is_view 'SELECT 1 AS id;', dependencies: [DependencyCheckBase1, DependencyCheckBase2]
+        end
+      }.to raise_error ArgumentError, 'DependencyCheckBase1 and DependencyCheckBase2 are not dependencies of DependencyCheckExtra2'
+
+      expect {
+        class DependencyCheckWrongType < ActiveRecord::Base
+          is_view 'SELECT 1;', dependencies: %w[DependencyCheckBase1]
+        end
+      }.to raise_error ArgumentError, 'dependencies must be ActiveRecord classes'
+
+      expect(view_names).to match_array %w[
+        dependency_check_base1
+        dependency_check_base2
+        dependency_check_base_unmanaged
+
+        dependency_check_goods
+        dependency_check_good_unmanageds
+      ]
+    end
   end
 end

data/spec/active_record_views_spec.rb

@@ -20,14 +20,6 @@ describe ActiveRecordViews do
       SQL
     end
 
-    def view_names
-      connection.select_values(<<-SQL.squish)
-        SELECT table_name
-        FROM information_schema.views
-        WHERE table_schema = 'public'
-      SQL
-    end
-
     def test_materialized_view_sql
       connection.select_value(<<-SQL.squish).try(&:squish)
         SELECT definition
@@ -36,14 +28,6 @@ describe ActiveRecordViews do
       SQL
     end
 
-    def materialized_view_names
-      connection.select_values(<<-SQL.squish)
-        SELECT matviewname
-        FROM pg_matviews
-        WHERE schemaname = 'public'
-      SQL
-    end
-
     it 'creates database view' do
       expect(test_view_sql).to be_nil
       create_test_view 'select 1 as id'
@@ -57,7 +41,7 @@ describe ActiveRecordViews do
           'name' => 'test',
           'class_name' => 'Test',
           'checksum' => Digest::SHA1.hexdigest('select 1 as id'),
-          'options' => '{"materialized":true}',
+          'options' => '{"materialized":true,"dependencies":[]}',
         }
       ]
     end
@@ -95,32 +79,26 @@ describe ActiveRecordViews do
 
       context 'having dependant views' do
         before do
-          ActiveRecordViews.create_view connection, 'dependency1', 'Dependency1', 'SELECT id FROM test;'
-          ActiveRecordViews.create_view connection, 'dependency2a', 'Dependency2a', 'SELECT id, id * 2 AS id2 FROM dependency1;'
-          ActiveRecordViews.create_view connection, 'dependency2b', 'Dependency2b', 'SELECT id, id * 4 AS id4 FROM dependency1;'
-          ActiveRecordViews.create_view connection, 'dependency3', 'Dependency3', 'SELECT * FROM dependency2b;'
-          ActiveRecordViews.create_view connection, 'dependency4', 'Dependency4', 'SELECT id FROM dependency1 UNION ALL SELECT id FROM dependency3;'
-        end
-
-        after do
-          dependants = %w[test dependency1 dependency2a dependency2b dependency3 dependency4]
-          expect(view_names).to match_array dependants
-          dependants.reverse.each do |name|
-            ActiveRecordViews.drop_view connection, name
+          without_dependency_checks do
+            ActiveRecordViews.create_view connection, 'dependant1', 'Dependant1', 'SELECT id FROM test;'
+            ActiveRecordViews.create_view connection, 'dependant2a', 'Dependant2a', 'SELECT id, id * 2 AS id2 FROM dependant1;'
+            ActiveRecordViews.create_view connection, 'dependant2b', 'Dependant2b', 'SELECT id, id * 4 AS id4 FROM dependant1;'
+            ActiveRecordViews.create_view connection, 'dependant3', 'Dependant3', 'SELECT * FROM dependant2b;'
+            ActiveRecordViews.create_view connection, 'dependant4', 'Dependant4', 'SELECT id FROM dependant1 UNION ALL SELECT id FROM dependant3;'
           end
         end
 
         it 'updates view with compatible change' do
           create_test_view 'select 2 as id'
           expect(test_view_sql).to eq 'SELECT 2 AS id;'
-          expect(connection.select_value('SELECT id2 FROM dependency2a')).to eq '4'
+          expect(connection.select_value('SELECT id2 FROM dependant2a')).to eq '4'
         end
 
         describe 'changes incompatible with CREATE OR REPLACE' do
           it 'updates view with new column added before existing' do
             create_test_view "select 'foo'::text as name, 3 as id"
             expect(test_view_sql).to eq "SELECT 'foo'::text AS name, 3 AS id;"
-            expect(connection.select_value('SELECT id2 FROM dependency2a')).to eq '6'
+            expect(connection.select_value('SELECT id2 FROM dependant2a')).to eq '6'
           end
 
           it 'fails to update view if column used by dependant view is removed' do
@@ -128,18 +106,44 @@ describe ActiveRecordViews do
               create_test_view "select 'foo'::text as name"
             }.to raise_error ActiveRecord::StatementInvalid, /column test.id does not exist/
             expect(test_view_sql).to eq 'SELECT 1 AS id;'
-            expect(connection.select_value('SELECT id2 FROM dependency2a')).to eq '2'
+            expect(connection.select_value('SELECT id2 FROM dependant2a')).to eq '2'
+          end
+        end
+
+        describe '.drop_all_views' do
+          it 'can drop all managed views' do
+            connection.execute 'CREATE VIEW unmanaged AS SELECT 2 AS id;'
+
+            expect(view_names).to match_array %w[test dependant1 dependant2a dependant2b dependant3 dependant4 unmanaged]
+            ActiveRecordViews.drop_all_views connection
+            expect(view_names).to match_array %w[unmanaged]
+          end
+
+          it 'errors if an unmanaged view depends on a managed view' do
+            connection.execute 'CREATE VIEW unmanaged AS SELECT * from dependant2a'
+
+            expect {
+              ActiveRecordViews.drop_all_views connection
+            }.to raise_error ActiveRecord::StatementInvalid, /view unmanaged depends on view dependant2a/
+          end
+
+          it 'can drop materialized views' do
+            without_dependency_checks do
+              ActiveRecordViews.create_view connection, 'materialized', 'Materialized', 'SELECT id FROM test;', materialized: true
+            end
+            ActiveRecordViews.drop_all_views connection
+            expect(view_names).to match_array %w[]
           end
         end
       end
 
       describe 'with unmanaged dependant view' do
         before do
-          connection.execute 'CREATE VIEW dependency AS SELECT id FROM test'
+          connection.execute 'CREATE VIEW dependant AS SELECT id FROM test'
         end
 
         after do
-          connection.execute 'DROP VIEW dependency;'
+          connection.execute 'DROP VIEW dependant;'
         end
 
         it 'updates view with compatible change' do
@@ -150,7 +154,7 @@ describe ActiveRecordViews do
         it 'fails to update view with incompatible change' do
           expect {
             create_test_view "SELECT 'foo'::text as name, 4 as id"
-          }.to raise_error ActiveRecord::StatementInvalid, /view dependency depends on view test/
+          }.to raise_error ActiveRecord::StatementInvalid, /view dependant depends on view test/
           expect(test_view_sql).to eq 'SELECT 1 AS id;'
         end
       end
@@ -187,9 +191,11 @@ describe ActiveRecordViews do
     end
 
     it 'preserves materialized view if dropping/recreating' do
-      ActiveRecordViews.create_view connection, 'test1', 'Test1', 'SELECT 1 AS foo'
-      ActiveRecordViews.create_view connection, 'test2', 'Test2', 'SELECT * FROM test1', materialized: true
-      ActiveRecordViews.create_view connection, 'test1', 'Test1', 'SELECT 2 AS bar, 1 AS foo'
+      without_dependency_checks do
+        ActiveRecordViews.create_view connection, 'test1', 'Test1', 'SELECT 1 AS foo'
+        ActiveRecordViews.create_view connection, 'test2', 'Test2', 'SELECT * FROM test1', materialized: true
+        ActiveRecordViews.create_view connection, 'test1', 'Test1', 'SELECT 2 AS bar, 1 AS foo'
+      end
 
       expect(materialized_view_names).to eq %w[test2]
       expect(view_names).to eq %w[test1]

data/spec/internal/app/models/dependency_b.rb

@@ -1,3 +1,3 @@
 class DependencyB < ActiveRecord::Base
-  is_view "SELECT id FROM #{DependencyA.table_name};"
+  is_view "SELECT id FROM #{DependencyA.table_name};", dependencies: [DependencyA]
 end

data/spec/internal/app/models/dependency_c.rb

@@ -1,3 +1,3 @@
 class DependencyC < ActiveRecord::Base
-  is_view "SELECT id FROM #{DependencyB.table_name};"
+  is_view "SELECT id FROM #{DependencyB.table_name};", dependencies: [DependencyB]
 end

data/spec/internal/app/models/modified_b.rb

@@ -1,3 +1,3 @@
 class ModifiedB < ActiveRecord::Base
-  is_view "SELECT new_name FROM #{ModifiedA.table_name};"
+  is_view "SELECT new_name FROM #{ModifiedA.table_name};", dependencies: [ModifiedA]
 end

data/spec/spec_helper.rb

@@ -69,3 +69,26 @@ def update_file(file, new_content)
   File.write file, new_content
   File.utime time, time, file
 end
+
+def view_names
+  ActiveRecord::Base.connection.select_values(<<-SQL.squish)
+    SELECT table_name
+    FROM information_schema.views
+    WHERE table_schema = 'public'
+  SQL
+end
+
+def materialized_view_names
+  ActiveRecord::Base.connection.select_values(<<-SQL.squish)
+    SELECT matviewname
+    FROM pg_matviews
+    WHERE schemaname = 'public'
+  SQL
+end
+
+def without_dependency_checks
+  allow(ActiveRecordViews).to receive(:check_dependencies)
+  yield
+ensure
+  allow(ActiveRecordViews).to receive(:check_dependencies).and_call_original
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_views
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Jason Weathered
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-19 00:00:00.000000000 Z
+date: 2015-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord