Merge pull request #531 from glitch-soc/454-allow-keyword-mutes-to-skip-mentions

Allow keyword mutes to skip mentions (#454)

2 files changed, 33 insertions, 29 deletions

diff --git a/spec/models/glitch/keyword_mute_helper_spec.rb b/spec/models/glitch/keyword_mute_helper_spec.rb
index b3f991d5b..f9408d62d 100644
--- a/spec/models/glitch/keyword_mute_helper_spec.rb
+++ b/spec/models/glitch/keyword_mute_helper_spec.rb
@@ -2,6 +2,8 @@ require 'rails_helper'
 
 RSpec.describe Glitch::KeywordMuteHelper do
   describe '#matches?' do
+    Unscoped = Glitch::KeywordMute::Scopes::Unscoped
+
     let(:alice) { Fabricate(:account, username: 'alice').tap(&:save!) }
     let(:helper) { Glitch::KeywordMuteHelper.new(alice) }
 
@@ -9,42 +11,42 @@ RSpec.describe Glitch::KeywordMuteHelper do
       status = Fabricate(:status, text: '<addr>uh example</addr>')
       Glitch::KeywordMute.create!(account: alice, keyword: 'addr')
 
-      expect(helper.matches?(status)).to be false
+      expect(helper.matches?(status, Unscoped)).to be false
     end
 
     it 'ignores properties of HTML tags in status text' do
       status = Fabricate(:status, text: '<a href="https://www.example.org">uh example</a>')
       Glitch::KeywordMute.create!(account: alice, keyword: 'href')
 
-      expect(helper.matches?(status)).to be false
+      expect(helper.matches?(status, Unscoped)).to be false
     end
 
     it 'matches text inside HTML tags' do
       status = Fabricate(:status, text: '<p>HEY THIS IS SOMETHING ANNOYING</p>')
       Glitch::KeywordMute.create!(account: alice, keyword: 'annoying')
 
-      expect(helper.matches?(status)).to be true
+      expect(helper.matches?(status, Unscoped)).to be true
     end
 
     it 'matches < in HTML-stripped text' do
       status = Fabricate(:status, text: '<p>I <3 oats</p>')
       Glitch::KeywordMute.create!(account: alice, keyword: '<3')
 
-      expect(helper.matches?(status)).to be true
+      expect(helper.matches?(status, Unscoped)).to be true
     end
 
     it 'matches &lt; in HTML text' do
       status = Fabricate(:status, text: '<p>I &lt;3 oats</p>')
       Glitch::KeywordMute.create!(account: alice, keyword: '<3')
 
-      expect(helper.matches?(status)).to be true
+      expect(helper.matches?(status, Unscoped)).to be true
     end
 
     it 'matches link hrefs in HTML text' do
       status = Fabricate(:status, text: '<p><a href="https://example.com/it-was-milk">yep</a></p>')
       Glitch::KeywordMute.create!(account: alice, keyword: 'milk')
 
-      expect(helper.matches?(status)).to be true
+      expect(helper.matches?(status, Unscoped)).to be true
     end
   end
 end
diff --git a/spec/models/glitch/keyword_mute_spec.rb b/spec/models/glitch/keyword_mute_spec.rb
index 443832ac7..12c354738 100644
--- a/spec/models/glitch/keyword_mute_spec.rb
+++ b/spec/models/glitch/keyword_mute_spec.rb
@@ -4,6 +4,8 @@ RSpec.describe Glitch::KeywordMute, type: :model do
   let(:alice) { Fabricate(:account, username: 'alice').tap(&:save!) }
   let(:bob) { Fabricate(:account, username: 'bob').tap(&:save!) }
 
+  Unscoped = Glitch::KeywordMute::Scopes::Unscoped
+
   describe '.text_matcher_for' do
     let(:matcher) { Glitch::KeywordMute.text_matcher_for(alice.id) }
 
@@ -13,7 +15,7 @@ RSpec.describe Glitch::KeywordMute, type: :model do
       end
 
       it 'does not match' do
-        expect(matcher.matches?('This is a hot take')).to be_falsy
+        expect(matcher.matches?('This is a hot take', Unscoped)).to be_falsy
       end
     end
 
@@ -21,87 +23,87 @@ RSpec.describe Glitch::KeywordMute, type: :model do
       it 'does not match keywords set by a different account' do
         Glitch::KeywordMute.create!(account: bob, keyword: 'take')
 
-        expect(matcher.matches?('This is a hot take')).to be_falsy
+        expect(matcher.matches?('This is a hot take', Unscoped)).to be_falsy
       end
 
       it 'does not match if no keywords match the status text' do
         Glitch::KeywordMute.create!(account: alice, keyword: 'cold')
 
-        expect(matcher.matches?('This is a hot take')).to be_falsy
+        expect(matcher.matches?('This is a hot take', Unscoped)).to be_falsy
       end
 
       it 'considers word boundaries when matching' do
         Glitch::KeywordMute.create!(account: alice, keyword: 'bob', whole_word: true)
 
-        expect(matcher.matches?('bobcats')).to be_falsy
+        expect(matcher.matches?('bobcats', Unscoped)).to be_falsy
       end
 
       it 'matches substrings if whole_word is false' do
         Glitch::KeywordMute.create!(account: alice, keyword: 'take', whole_word: false)
 
-        expect(matcher.matches?('This is a shiitake mushroom')).to be_truthy
+        expect(matcher.matches?('This is a shiitake mushroom', Unscoped)).to be_truthy
       end
 
       it 'matches keywords at the beginning of the text' do
         Glitch::KeywordMute.create!(account: alice, keyword: 'take')
 
-        expect(matcher.matches?('Take this')).to be_truthy
+        expect(matcher.matches?('Take this', Unscoped)).to be_truthy
       end
 
       it 'matches keywords at the end of the text' do
         Glitch::KeywordMute.create!(account: alice, keyword: 'take')
 
-        expect(matcher.matches?('This is a hot take')).to be_truthy
+        expect(matcher.matches?('This is a hot take', Unscoped)).to be_truthy
       end
 
       it 'matches if at least one keyword case-insensitively matches the text' do
         Glitch::KeywordMute.create!(account: alice, keyword: 'hot')
 
-        expect(matcher.matches?('This is a HOT take')).to be_truthy
+        expect(matcher.matches?('This is a HOT take', Unscoped)).to be_truthy
       end
 
       it 'matches if at least one non-whole-word keyword case-insensitively matches the text' do
         Glitch::KeywordMute.create!(account: alice, keyword: 'hot', whole_word: false)
 
-        expect(matcher.matches?('This is a HOTTY take')).to be_truthy
+        expect(matcher.matches?('This is a HOTTY take', Unscoped)).to be_truthy
       end
 
       it 'maintains case-insensitivity when combining keywords into a single matcher' do
         Glitch::KeywordMute.create!(account: alice, keyword: 'hot')
         Glitch::KeywordMute.create!(account: alice, keyword: 'cold')
 
-        expect(matcher.matches?('This is a HOT take')).to be_truthy
+        expect(matcher.matches?('This is a HOT take', Unscoped)).to be_truthy
       end
 
       it 'matches keywords surrounded by non-alphanumeric ornamentation' do
         Glitch::KeywordMute.create!(account: alice, keyword: 'hot')
 
-        expect(matcher.matches?('(hot take)')).to be_truthy
+        expect(matcher.matches?('(hot take)', Unscoped)).to be_truthy
       end
 
       it 'escapes metacharacters in whole-word keywords' do
         Glitch::KeywordMute.create!(account: alice, keyword: '(hot take)')
 
-        expect(matcher.matches?('(hot take)')).to be_truthy
+        expect(matcher.matches?('(hot take)', Unscoped)).to be_truthy
       end
 
       it 'escapes metacharacters in non-whole-word keywords' do
         Glitch::KeywordMute.create!(account: alice, keyword: '(-', whole_word: false)
 
-        expect(matcher.matches?('bad (-)')).to be_truthy
+        expect(matcher.matches?('bad (-)', Unscoped)).to be_truthy
       end
 
       it 'uses case-folding rules appropriate for more than just English' do
         Glitch::KeywordMute.create!(account: alice, keyword: 'großeltern')
 
-        expect(matcher.matches?('besuch der grosseltern')).to be_truthy
+        expect(matcher.matches?('besuch der grosseltern', Unscoped)).to be_truthy
       end
 
       it 'matches keywords that are composed of multiple words' do
         Glitch::KeywordMute.create!(account: alice, keyword: 'a shiitake')
 
-        expect(matcher.matches?('This is a shiitake')).to be_truthy
-        expect(matcher.matches?('This is shiitake')).to_not be_truthy
+        expect(matcher.matches?('This is a shiitake', Unscoped)).to be_truthy
+        expect(matcher.matches?('This is shiitake', Unscoped)).to_not be_truthy
       end
     end
   end
@@ -118,7 +120,7 @@ RSpec.describe Glitch::KeywordMute, type: :model do
       it 'does not match' do
         status.tags << Fabricate(:tag, name: 'xyzzy')
 
-        expect(matcher.matches?(status.tags)).to be false
+        expect(matcher.matches?(status.tags, Unscoped)).to be false
       end
     end
 
@@ -127,42 +129,42 @@ RSpec.describe Glitch::KeywordMute, type: :model do
         status.tags << Fabricate(:tag, name: 'xyzzy')
         Glitch::KeywordMute.create!(account: bob, keyword: 'take')
 
-        expect(matcher.matches?(status.tags)).to be false
+        expect(matcher.matches?(status.tags, Unscoped)).to be false
       end
 
       it 'matches #xyzzy when given the mute "#xyzzy"' do
         status.tags << Fabricate(:tag, name: 'xyzzy')
         Glitch::KeywordMute.create!(account: alice, keyword: '#xyzzy')
 
-        expect(matcher.matches?(status.tags)).to be true
+        expect(matcher.matches?(status.tags, Unscoped)).to be true
       end
 
       it 'matches #thingiverse when given the non-whole-word mute "#thing"' do
         status.tags << Fabricate(:tag, name: 'thingiverse')
         Glitch::KeywordMute.create!(account: alice, keyword: '#thing', whole_word: false)
 
-        expect(matcher.matches?(status.tags)).to be true
+        expect(matcher.matches?(status.tags, Unscoped)).to be true
       end
 
       it 'matches #hashtag when given the mute "##hashtag""' do
         status.tags << Fabricate(:tag, name: 'hashtag')
         Glitch::KeywordMute.create!(account: alice, keyword: '##hashtag')
 
-        expect(matcher.matches?(status.tags)).to be true
+        expect(matcher.matches?(status.tags, Unscoped)).to be true
       end
 
       it 'matches #oatmeal when given the non-whole-word mute "oat"' do
         status.tags << Fabricate(:tag, name: 'oatmeal')
         Glitch::KeywordMute.create!(account: alice, keyword: 'oat', whole_word: false)
 
-        expect(matcher.matches?(status.tags)).to be true
+        expect(matcher.matches?(status.tags, Unscoped)).to be true
       end
 
       it 'does not match #oatmeal when given the mute "#oat"' do
         status.tags << Fabricate(:tag, name: 'oatmeal')
         Glitch::KeywordMute.create!(account: alice, keyword: 'oat')
 
-        expect(matcher.matches?(status.tags)).to be false
+        expect(matcher.matches?(status.tags, Unscoped)).to be false
       end
     end
   end