redirector 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad42ef21589444516bcf0d1b6d381d2c1db2e560
-  data.tar.gz: 127e4f057f0d017d22dde3aaab39cf5fd574870b
+  metadata.gz: 63dab49a33d2664b3722c5240d71328cd50ec1ba
+  data.tar.gz: 7baceb65e027c70c8db19a9b62d8e598a3c27e32
 SHA512:
-  metadata.gz: 3b48d0cb2e7fe015b01d3e4fd8932ad56c72c5e91bd759f5baa4aa956476f1b92caecd595f19fe8dbe1575e5c76c30ac926a8f41a5b2507a004ba72d42fcfbf8
-  data.tar.gz: d0ce4195ebbd8ffaa7859fa52518094d82a0858e523f8a8115a6015d79382e9b40c80adfe5f60aba5cd679bf74e696e461db2866d0fdf07249dbcd57b2e0fd40
+  metadata.gz: 209ce7d1b98f706a3e44dd6262c732545b36b8e62fdde2e5261a0292b36105f71ee8d5fbc7f43d66ce7c8c1cac2a582ad82b7c97a26172492d1866531f2fdffe
+  data.tar.gz: 26d3ca13b233ea6e2882c6e2aaf5750cc1402d31cd74343cabe6dffb3d5a10e2a428340a46edf51eae594876038951f42beb2978fdad4353d6da0fca91e1e91f

data/db/migrate/20120815212612_create_redirect_rules.rb

@@ -1,4 +1,4 @@
-class CreateRedirectRules < ActiveRecord::Migration
+class CreateRedirectRules < ActiveRecord::Migration[4.2]
   def change
     create_table :redirect_rules do |t|
       t.string :source, :null => false
@@ -13,4 +13,4 @@ class CreateRedirectRules < ActiveRecord::Migration
     add_index :redirect_rules, :source_is_regex
     add_index :redirect_rules, :source_is_case_sensitive
   end
-end
+end

data/db/migrate/20120823163756_create_request_environment_rules.rb

@@ -1,4 +1,4 @@
-class CreateRequestEnvironmentRules < ActiveRecord::Migration
+class CreateRequestEnvironmentRules < ActiveRecord::Migration[4.2]
   def change
     create_table :request_environment_rules do |t|
       t.integer :redirect_rule_id, :null => false
@@ -10,4 +10,4 @@ class CreateRequestEnvironmentRules < ActiveRecord::Migration
     end
     add_index :request_environment_rules, :redirect_rule_id
   end
-end
+end

data/lib/redirector/version.rb

@@ -1,3 +1,3 @@
 module Redirector
-  VERSION = "1.0.2"
+  VERSION = "1.1.0"
 end

data/redirector.gemspec

@@ -22,11 +22,11 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency "mysql2"
   s.add_development_dependency "pg"
-  s.add_development_dependency 'rspec-rails', '~> 2.14.2'
+  s.add_development_dependency 'rspec-rails', '~> 3.7'
   s.add_development_dependency 'shoulda-matchers'
   s.add_development_dependency 'capybara', '~> 2.2'
   s.add_development_dependency 'database_cleaner'
-  s.add_development_dependency 'factory_girl_rails', '~> 4.4'
+  s.add_development_dependency 'factory_bot_rails', '~> 4.4'
   s.add_development_dependency 'appraisal'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'coveralls'

data/spec/dummy/config/application.rb

@@ -50,10 +50,10 @@ module Dummy
     # config.active_record.whitelist_attributes = true
 
     # Enable the asset pipeline
-    config.assets.enabled = true
+    # config.assets.enabled = true
 
     # Version of your assets, change this if you want to expire all your assets
-    config.assets.version = '1.0'
+    # config.assets.version = '1.0'
   end
 end
 

data/spec/factories/redirect_rules.rb

@@ -1,12 +1,12 @@
-# Read about factories at https://github.com/thoughtbot/factory_girl
+# Read about factories at https://github.com/thoughtbot/factory_bot
 
-FactoryGirl.define do
+FactoryBot.define do
   factory :redirect_rule do
     active true
     source_is_regex false
     source '/catchy_thingy'
     destination 'http://www.example.com/products/1'
-    
+
     factory :redirect_rule_regex do
       source_is_regex true
       source '[A-Za-z0-9_]+shiny\/([A-Za-z0-9_]+)'

data/spec/factories/request_environment_rules.rb

@@ -1,11 +1,11 @@
-# Read about factories at https://github.com/thoughtbot/factory_girl
+# Read about factories at https://github.com/thoughtbot/factory_bot
 
-FactoryGirl.define do
+FactoryBot.define do
   factory :request_environment_rule do
     redirect_rule
     environment_key_name "SERVER_NAME"
     environment_value "example.com"
-    
+
     factory :request_environment_rule_regex do
       environment_key_name "QUERY_STRING"
       environment_value "something=value"

data/spec/features/middleware_spec.rb

@@ -9,24 +9,24 @@ describe 'Redirector middleware', :type => :feature do
 
   it 'correctly redirects the visitor for an exact match rule' do
     visit '/my_custom_url'
-    current_path.should == '/news/5'
+    expect(current_path).to eq('/news/5')
   end
 
   it 'correctly redirects the visitor for a regex match rule' do
     visit '/my_custom_url/20'
-    current_path.should == '/news/20'
+    expect(current_path).to eq('/news/20')
   end
 
   it 'should not do the query string match if the Redirector.include_query_in_source is false' do
     visit '/my_old_url?categoryID=12345'
-    current_path.should == '/my_old_url'
+    expect(current_path).to eq('/my_old_url')
   end
 
   it 'should do the query string match if the Redirector.include_query_in_source is true' do
     original_option = Redirector.include_query_in_source
     Redirector.include_query_in_source = true
     visit '/my_old_url?categoryID=12345'
-    current_path.should == '/news'
+    expect(current_path).to eq('/news')
     Redirector.include_query_in_source = original_option
   end
 
@@ -35,8 +35,8 @@ describe 'Redirector middleware', :type => :feature do
     Redirector.preserve_query = true
     visit '/my_custom_url/20?categoryID=43257'
     uri = URI.parse(current_url)
-    uri.query.should == 'categoryID=43257'
-    current_path.should == '/news/20'
+    expect(uri.query).to eq('categoryID=43257')
+    expect(current_path).to eq('/news/20')
     Redirector.preserve_query = original_option
   end
 
@@ -44,7 +44,7 @@ describe 'Redirector middleware', :type => :feature do
     original_option = Redirector.silence_sql_logs
     Redirector.silence_sql_logs = true
     visit '/my_custom_url/20'
-    current_path.should == '/news/20'
+    expect(current_path).to eq('/news/20')
     Redirector.preserve_query = original_option
   end
 
@@ -52,12 +52,12 @@ describe 'Redirector middleware', :type => :feature do
     Capybara.app_host = 'http://example.com'
 
     visit '/my_custom_url'
-    current_url.should == 'http://example.com/news/5'
+    expect(current_url).to eq('http://example.com/news/5')
 
     Capybara.app_host = 'http://example.com:3000'
 
     visit '/my_custom_url'
-    current_url.should == 'http://example.com:3000/news/5'
+    expect(current_url).to eq('http://example.com:3000/news/5')
   end
 
   it 'foregoes search if ignored path pattern is detected' do
@@ -65,19 +65,22 @@ describe 'Redirector middleware', :type => :feature do
     Redirector.ignored_patterns = [/^\/my_custom_url\/.+/]
 
     visit '/my_custom_url/20'
-    current_path.should == '/my_custom_url/20'
+    expect(current_path).to eq('/my_custom_url/20')
 
     Redirector.ignored_patterns = original_option
   end
 
   unless Rails.version =~ /\A4\.2\.\d\z/
     it 'handles invalid URIs properly' do
-      bad_rule = create(:redirect_rule_regex, :destination => 'http://www.example.com$1', :source => '^/custom(.*)$')
+      bad_rule = create(:redirect_rule_regex,
+        :destination => 'http://www.example.com/invalid)e2',
+        :source => '^/custom(.*)$',
+      )
 
       begin
-        visit '/custom)e2'
+        visit '/custome2'
       rescue Redirector::RuleError => e
-        e.message.should == "RedirectRule #{bad_rule.id} generated the bad destination: http://www.example.com)e2"
+        expect(e.message).to eq("RedirectRule #{bad_rule.id} generated the bad destination: http://www.example.com)e2")
       end
     end
   end

data/spec/models/redirect_rule_spec.rb

@@ -4,61 +4,66 @@ describe RedirectRule do
   subject { create(:redirect_rule) }
   let!(:rule) { subject }
 
-  it { should have_many(:request_environment_rules) }
+  it { is_expected.to have_many(:request_environment_rules) }
 
-  it { should accept_nested_attributes_for(:request_environment_rules) }
+  it { is_expected.to accept_nested_attributes_for(:request_environment_rules) }
 
-  it { should validate_presence_of(:source) }
-  it { should validate_presence_of(:destination) }
+  it { is_expected.to validate_presence_of(:source) }
+  it { is_expected.to validate_presence_of(:destination) }
 
-  it { should allow_value('0').for(:active) }
-  it { should allow_value('1').for(:active) }
-  it { should allow_value(true).for(:active) }
-  it { should allow_value(false).for(:active) }
+  it { is_expected.to allow_value('0').for(:active) }
+  it { is_expected.to allow_value('1').for(:active) }
+  it { is_expected.to allow_value(true).for(:active) }
+  it { is_expected.to allow_value(false).for(:active) }
 
-  it { should allow_value('0').for(:source_is_regex) }
-  it { should allow_value('1').for(:source_is_regex) }
-  it { should allow_value(true).for(:source_is_regex) }
-  it { should allow_value(false).for(:source_is_regex) }
+  it { is_expected.to allow_value('0').for(:source_is_regex) }
+  it { is_expected.to allow_value('1').for(:source_is_regex) }
+  it { is_expected.to allow_value(true).for(:source_is_regex) }
+  it { is_expected.to allow_value(false).for(:source_is_regex) }
 
-  it { should allow_value('0').for(:source_is_case_sensitive) }
-  it { should allow_value('1').for(:source_is_case_sensitive) }
-  it { should allow_value(true).for(:source_is_case_sensitive) }
-  it { should allow_value(false).for(:source_is_case_sensitive) }
+  it { is_expected.to allow_value('0').for(:source_is_case_sensitive) }
+  it { is_expected.to allow_value('1').for(:source_is_case_sensitive) }
+  it { is_expected.to allow_value(true).for(:source_is_case_sensitive) }
+  it { is_expected.to allow_value(false).for(:source_is_case_sensitive) }
 
   it 'should not allow an invalid regex' do
-    new_rule = RedirectRule.new(:source => '[', :source_is_regex => true,
-      :destination => 'http://www.example.com', :active => true)
-    new_rule.errors_on(:source).should == ['is an invalid regular expression']
+    new_rule = RedirectRule.new(
+      :source => '[',
+      :source_is_regex => true,
+      :destination => 'http://www.example.com',
+      :active => true
+    )
+    new_rule.validate
+    expect(new_rule.errors[:source]).to eq(['is an invalid regular expression'])
   end
 
   describe 'strip_source_whitespace before_save callback' do
     it 'strips leading and trailing whitespace when saved' do
-      subject = FactoryGirl.build(:redirect_rule, :source => ' /needs-stripping ')
+      subject = FactoryBot.build(:redirect_rule, :source => ' /needs-stripping ')
 
       subject.save
-      subject.reload.source.should == '/needs-stripping'
+      expect(subject.reload.source).to eq('/needs-stripping')
     end
   end
 
   describe '.match_for' do
     it 'returns nil if there is no matching rule' do
-      RedirectRule.match_for('/someplace', {}).should be_nil
+      expect(RedirectRule.match_for('/someplace', {})).to be_nil
     end
 
     it 'returns the rule if there is a matching rule' do
-      RedirectRule.match_for('/catchy_thingy', {}).should == subject
+      expect(RedirectRule.match_for('/catchy_thingy', {})).to eq(subject)
     end
 
     context 'for a case sensitive match' do
       let!(:case_sensitive_rule) { create(:redirect_rule, :source_is_case_sensitive => true, :source => '/Case-Does-Matter') }
 
       it 'returns the rule if it matches the case' do
-        RedirectRule.match_for('/Case-Does-Matter', {}).should == case_sensitive_rule
+        expect(RedirectRule.match_for('/Case-Does-Matter', {})).to eq(case_sensitive_rule)
       end
 
       it 'returns nil if it does not match the case' do
-        RedirectRule.match_for('/case-does-matter', {}).should be_nil
+        expect(RedirectRule.match_for('/case-does-matter', {})).to be_nil
       end
     end
 
@@ -66,11 +71,11 @@ describe RedirectRule do
       let!(:case_insensitive_rule) { create(:redirect_rule, :source_is_case_sensitive => false, :source => '/Case-Does-Not-Matter') }
 
       it 'returns the rule if it matches the case' do
-        RedirectRule.match_for('/Case-Does-Not-Matter', {}).should == case_insensitive_rule
+        expect(RedirectRule.match_for('/Case-Does-Not-Matter', {})).to eq(case_insensitive_rule)
       end
 
       it 'returns the rule if it does not match the case' do
-        RedirectRule.match_for('/case-does-not-matter', {}).should == case_insensitive_rule
+        expect(RedirectRule.match_for('/case-does-not-matter', {})).to eq(case_insensitive_rule)
       end
     end
 
@@ -78,11 +83,11 @@ describe RedirectRule do
       let!(:regex_rule){ create(:redirect_rule_regex, :source_is_case_sensitive => true) }
 
       it 'returns the rule if it matches the case' do
-        RedirectRule.match_for('/new_shiny/from_company', {}).should == regex_rule
+        expect(RedirectRule.match_for('/new_shiny/from_company', {})).to eq(regex_rule)
       end
 
       it 'returns nil if it does not match the case' do
-        RedirectRule.match_for('/new_SHINY/from_company', {}).should be_nil
+        expect(RedirectRule.match_for('/new_SHINY/from_company', {})).to be_nil
       end
     end
 
@@ -90,11 +95,11 @@ describe RedirectRule do
       let!(:regex_rule){ create(:redirect_rule_regex) }
 
       it 'returns the rule if it matches the case' do
-        RedirectRule.match_for('/new_shiny/from_company', {}).should == regex_rule
+        expect(RedirectRule.match_for('/new_shiny/from_company', {})).to eq(regex_rule)
       end
 
       it 'returns the rule if it does not match the case' do
-        RedirectRule.match_for('/new_SHINY/from_company', {}).should == regex_rule
+        expect(RedirectRule.match_for('/new_SHINY/from_company', {})).to eq(regex_rule)
       end
     end
 
@@ -104,11 +109,11 @@ describe RedirectRule do
       end
 
       it 'should find the rule if it matches' do
-        RedirectRule.match_for('/catchy_thingy', {'SERVER_NAME' => 'example.com'}).should == subject
+        expect(RedirectRule.match_for('/catchy_thingy', {'SERVER_NAME' => 'example.com'})).to eq(subject)
       end
 
       it 'should not find the rule if there is no match' do
-        RedirectRule.match_for('/catchy_thingy', {'SERVER_NAME' => 'example.ca'}).should be_nil
+        expect(RedirectRule.match_for('/catchy_thingy', {'SERVER_NAME' => 'example.ca'})).to be_nil
       end
     end
 
@@ -119,13 +124,13 @@ describe RedirectRule do
       end
 
       it 'should find the rule if it matches' do
-        RedirectRule.match_for('/catchy_thingy', {'SERVER_NAME' => 'example.com',
-          'QUERY_STRING' => 's=bogus&something=value'}).should == subject
+        expect(RedirectRule.match_for('/catchy_thingy', {'SERVER_NAME' => 'example.com',
+          'QUERY_STRING' => 's=bogus&something=value'})).to eq(subject)
       end
 
       it 'should not find the rule if there is no match' do
-        RedirectRule.match_for('/catchy_thingy', {'SERVER_NAME' => 'example.com',
-          "QUERY_STRING" => 's=bogus&something=wrong'}).should be_nil
+        expect(RedirectRule.match_for('/catchy_thingy', {'SERVER_NAME' => 'example.com',
+          "QUERY_STRING" => 's=bogus&something=wrong'})).to be_nil
       end
     end
 
@@ -140,18 +145,18 @@ describe RedirectRule do
       end
 
       it 'should find the rule if it matches' do
-        RedirectRule.match_for('/catchy_thingy', {'SERVER_NAME' => 'example.com',
-          'QUERY_STRING' => 's=bogus&something=value'}).should == subject
+        expect(RedirectRule.match_for('/catchy_thingy', {'SERVER_NAME' => 'example.com',
+          'QUERY_STRING' => 's=bogus&something=value'})).to eq(subject)
       end
 
       it 'should find the other rule if it matches' do
-        RedirectRule.match_for('/catchy_thingy', {'SERVER_NAME' => 'example.com',
-          'QUERY_STRING' => 's=bogus&another=value'}).should == rule2
+        expect(RedirectRule.match_for('/catchy_thingy', {'SERVER_NAME' => 'example.com',
+          'QUERY_STRING' => 's=bogus&another=value'})).to eq(rule2)
       end
 
       it 'should not find the rule if there is no match' do
-        RedirectRule.match_for('/catchy_thingy', {'SERVER_NAME' => 'example.com',
-          "QUERY_STRING" => 's=bogus&something=wrong'}).should be_nil
+        expect(RedirectRule.match_for('/catchy_thingy', {'SERVER_NAME' => 'example.com',
+          "QUERY_STRING" => 's=bogus&something=wrong'})).to be_nil
       end
     end
 
@@ -159,7 +164,7 @@ describe RedirectRule do
       let!(:regex_rule){ create(:redirect_rule_regex, :source => '[A-Za-z0-9]_thingy') }
 
       it 'should return the exact match' do
-        RedirectRule.match_for('/catchy_thingy', {}).should == subject
+        expect(RedirectRule.match_for('/catchy_thingy', {})).to eq(subject)
       end
     end
   end
@@ -168,15 +173,15 @@ describe RedirectRule do
     let!(:regex_rule) { create(:redirect_rule_regex) }
 
     it 'should find a regex match' do
-      RedirectRule.destination_for('/new_shiny/from_company', {}).should == 'http://www.example.com/news/from_company'
+      expect(RedirectRule.destination_for('/new_shiny/from_company', {})).to eq('http://www.example.com/news/from_company')
     end
 
     it 'should find a string match' do
-      RedirectRule.destination_for('/catchy_thingy', {}).should == 'http://www.example.com/products/1'
+      expect(RedirectRule.destination_for('/catchy_thingy', {})).to eq('http://www.example.com/products/1')
     end
 
     it 'should return nil if there is no matching rule' do
-      RedirectRule.destination_for('/someplace', {}).should be_nil
+      expect(RedirectRule.destination_for('/someplace', {})).to be_nil
     end
   end
 
@@ -184,11 +189,11 @@ describe RedirectRule do
     let(:regex_rule) { create(:redirect_rule_regex) }
 
     it 'returns the destination for a non regex rule' do
-      subject.evaluated_destination_for('/catchy_thingy').should == 'http://www.example.com/products/1'
+      expect(subject.evaluated_destination_for('/catchy_thingy')).to eq('http://www.example.com/products/1')
     end
 
     it 'returns the evaluated destination for a regex rule' do
-      regex_rule.evaluated_destination_for('/new_shiny/from_company').should == 'http://www.example.com/news/from_company'
+      expect(regex_rule.evaluated_destination_for('/new_shiny/from_company')).to eq('http://www.example.com/news/from_company')
     end
   end
 end

data/spec/models/request_environment_rule_spec.rb

@@ -3,43 +3,44 @@ require 'spec_helper'
 describe RequestEnvironmentRule do
   subject { create(:request_environment_rule) }
 
-  it { should belong_to(:redirect_rule) }
+  it { is_expected.to belong_to(:redirect_rule) }
 
-  it { should validate_presence_of(:redirect_rule) }
-  it { should validate_presence_of(:environment_key_name) }
-  it { should validate_presence_of(:environment_value) }
+  it { is_expected.to validate_presence_of(:redirect_rule) }
+  it { is_expected.to validate_presence_of(:environment_key_name) }
+  it { is_expected.to validate_presence_of(:environment_value) }
 
-  it { should allow_value('0').for(:environment_value_is_regex) }
-  it { should allow_value('1').for(:environment_value_is_regex) }
-  it { should allow_value(true).for(:environment_value_is_regex) }
-  it { should allow_value(false).for(:environment_value_is_regex) }
+  it { is_expected.to allow_value('0').for(:environment_value_is_regex) }
+  it { is_expected.to allow_value('1').for(:environment_value_is_regex) }
+  it { is_expected.to allow_value(true).for(:environment_value_is_regex) }
+  it { is_expected.to allow_value(false).for(:environment_value_is_regex) }
 
-  it { should allow_value('0').for(:environment_value_is_case_sensitive) }
-  it { should allow_value('1').for(:environment_value_is_case_sensitive) }
-  it { should allow_value(true).for(:environment_value_is_case_sensitive) }
-  it { should allow_value(false).for(:environment_value_is_case_sensitive) }
+  it { is_expected.to allow_value('0').for(:environment_value_is_case_sensitive) }
+  it { is_expected.to allow_value('1').for(:environment_value_is_case_sensitive) }
+  it { is_expected.to allow_value(true).for(:environment_value_is_case_sensitive) }
+  it { is_expected.to allow_value(false).for(:environment_value_is_case_sensitive) }
 
   it 'should not allow an invalid regex' do
     rule = build(:request_environment_rule_regex, :environment_value => '[')
-    rule.errors_on(:environment_value).should == ['is an invalid regular expression']
+    rule.validate
+    expect(rule.errors[:environment_value]).to eq(['is an invalid regular expression'])
   end
 
   it "should know if it's matched for a non-regex value" do
-    subject.matches?({'SERVER_NAME' => 'example.com'}).should be_true
-    subject.matches?({'HTTP_HOST' => 'www.example.com'}).should be_false
-    subject.matches?({'SERVER_NAME' => 'example.ca'}).should be_false
+    expect(subject.matches?({'SERVER_NAME' => 'example.com'})).to be_truthy
+    expect(subject.matches?({'HTTP_HOST' => 'www.example.com'})).to be_falsey
+    expect(subject.matches?({'SERVER_NAME' => 'example.ca'})).to be_falsey
   end
 
   context 'with a case sensitive regex value' do
     subject { create(:request_environment_rule_regex) }
 
     it "should know if it's matched" do
-      subject.matches?({'QUERY_STRING' => 'something=value'}).should be_true
-      subject.matches?({'QUERY_STRING' => 'q=search&something=value'}).should be_true
-      subject.matches?({'QUERY_STRING' => 'q=search&something=VALUE'}).should be_false
-      subject.matches?({'QUERY_STRING' => 'q=search&something=bogus'}).should be_false
-      subject.matches?({'QUERY_STRING' => 'q=search'}).should be_false
-      subject.matches?({'SERVER_NAME' => 'example.ca'}).should be_false
+      expect(subject.matches?({'QUERY_STRING' => 'something=value'})).to be_truthy
+      expect(subject.matches?({'QUERY_STRING' => 'q=search&something=value'})).to be_truthy
+      expect(subject.matches?({'QUERY_STRING' => 'q=search&something=VALUE'})).to be_falsey
+      expect(subject.matches?({'QUERY_STRING' => 'q=search&something=bogus'})).to be_falsey
+      expect(subject.matches?({'QUERY_STRING' => 'q=search'})).to be_falsey
+      expect(subject.matches?({'SERVER_NAME' => 'example.ca'})).to be_falsey
     end
   end
 
@@ -47,12 +48,12 @@ describe RequestEnvironmentRule do
     subject { create(:request_environment_rule_regex, :environment_value_is_case_sensitive => false) }
 
     it "should know if it's matched" do
-      subject.matches?({'QUERY_STRING' => 'something=value'}).should be_true
-      subject.matches?({'QUERY_STRING' => 'q=search&something=value'}).should be_true
-      subject.matches?({'QUERY_STRING' => 'q=search&something=VALUE'}).should be_true
-      subject.matches?({'QUERY_STRING' => 'q=search&something=bogus'}).should be_false
-      subject.matches?({'QUERY_STRING' => 'q=search'}).should be_false
-      subject.matches?({'SERVER_NAME' => 'example.ca'}).should be_false
+      expect(subject.matches?({'QUERY_STRING' => 'something=value'})).to be_truthy
+      expect(subject.matches?({'QUERY_STRING' => 'q=search&something=value'})).to be_truthy
+      expect(subject.matches?({'QUERY_STRING' => 'q=search&something=VALUE'})).to be_truthy
+      expect(subject.matches?({'QUERY_STRING' => 'q=search&something=bogus'})).to be_falsey
+      expect(subject.matches?({'QUERY_STRING' => 'q=search'})).to be_falsey
+      expect(subject.matches?({'SERVER_NAME' => 'example.ca'})).to be_falsey
     end
   end
 end

data/spec/spec_helper.rb

@@ -6,19 +6,19 @@ Coveralls.wear! 'rails'
 
 require File.expand_path("../dummy/config/environment.rb",  __FILE__)
 require 'rspec/rails'
-require 'rspec/autorun'
 require 'shoulda-matchers'
 require 'capybara/rails'
 require 'capybara/rspec'
 require 'database_cleaner'
-require 'factory_girl_rails'
+require 'factory_bot_rails'
+require 'pry'
 
 Rails.backtrace_cleaner.remove_silencers!
 
 DatabaseCleaner.strategy = :truncation
 
 RSpec.configure do |config|
-  config.include FactoryGirl::Syntax::Methods
+  config.include FactoryBot::Syntax::Methods
 
   config.mock_with :rspec
   config.use_transactional_fixtures = true
@@ -29,4 +29,22 @@ RSpec.configure do |config|
     Capybara.reset_sessions!    # Forget the (simulated) browser state
     Capybara.use_default_driver # Revert Capybara.current_driver to Capybara.default_driver
   end
+
+  # rspec-rails 3 will no longer automatically infer an example group's spec type
+  # from the file location. You can explicitly opt-in to the feature using this
+  # config option.
+  # To explicitly tag specs without using automatic inference, set the `:type`
+  # metadata manually:
+  #
+  #     describe ThingsController, :type => :controller do
+  #       # Equivalent to being in spec/controllers
+  #     end
+  config.infer_spec_type_from_file_location!
+end
+
+Shoulda::Matchers.configure do |config|
+  config.integrate do |with|
+    with.test_framework :rspec
+    with.library :rails
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redirector
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Brian Landau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-13 00:00:00.000000000 Z
+date: 2018-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.2
+        version: '3.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.14.2
+        version: '3.7'
 - !ruby/object:Gem::Dependency
   name: shoulda-matchers
   requirement: !ruby/object:Gem::Requirement
@@ -109,7 +109,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: factory_girl_rails
+  name: factory_bot_rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"