From c0a665865e5f06f45296e76bfef3790f8149b0ee Mon Sep 17 00:00:00 2001
From: beatrix-bitrot <beatrix.bitrot@gmail.com>
Date: Tue, 16 May 2017 02:25:53 +0000
Subject: update bio length to 500

---
 app/models/account.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'app/models')

diff --git a/app/models/account.rb b/app/models/account.rb
index 2b54cee5f..14c90cfc0 100644
--- a/app/models/account.rb
+++ b/app/models/account.rb
@@ -60,7 +60,7 @@ class Account < ApplicationRecord
   validates :username, format: { with: /\A[a-z0-9_]+\z/i }, uniqueness: { scope: :domain, case_sensitive: false }, length: { maximum: 30 }, if: -> { local? && will_save_change_to_username? }
   validates_with UnreservedUsernameValidator, if: -> { local? && will_save_change_to_username? }
   validates :display_name, length: { maximum: 30 }, if: -> { local? && will_save_change_to_display_name? }
-  validates :note, length: { maximum: 160 }, if: -> { local? && will_save_change_to_note? }
+  validates :note, length: { maximum: 500 }, if: -> { local? && will_save_change_to_note? }
 
   # Timelines
   has_many :stream_entries, inverse_of: :account, dependent: :destroy
-- 
cgit 


From 4f36aad6e8e1dad6b9907b62a200919fbe0d4ebe Mon Sep 17 00:00:00 2001
From: Surinna Curtis <ekiru.0@gmail.com>
Date: Sun, 25 Jun 2017 22:23:53 -0500
Subject: don't count bio metadata against bio length on server

---
 app/models/account.rb | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

(limited to 'app/models')

diff --git a/app/models/account.rb b/app/models/account.rb
index 14c90cfc0..49d2c88f6 100644
--- a/app/models/account.rb
+++ b/app/models/account.rb
@@ -60,7 +60,7 @@ class Account < ApplicationRecord
   validates :username, format: { with: /\A[a-z0-9_]+\z/i }, uniqueness: { scope: :domain, case_sensitive: false }, length: { maximum: 30 }, if: -> { local? && will_save_change_to_username? }
   validates_with UnreservedUsernameValidator, if: -> { local? && will_save_change_to_username? }
   validates :display_name, length: { maximum: 30 }, if: -> { local? && will_save_change_to_display_name? }
-  validates :note, length: { maximum: 500 }, if: -> { local? && will_save_change_to_note? }
+  validate :note_length_does_not_exceed_length_limit, if: -> { local? && will_save_change_to_note? }
 
   # Timelines
   has_many :stream_entries, inverse_of: :account, dependent: :destroy
@@ -251,6 +251,22 @@ class Account < ApplicationRecord
     self.public_key  = keypair.public_key.to_pem
   end
 
+  YAML_START = "---\r\n"
+  YAML_END = "\r\n...\r\n"
+
+  def note_length_does_not_exceed_length_limit
+    note_without_metadata = note
+    if note.start_with? YAML_START
+      idx = note.index YAML_END
+      unless idx.nil?
+        note_without_metadata = note[(idx + YAML_END.length) .. -1]
+      end
+    end
+    if note_without_metadata.mb_chars.grapheme_length > 500
+      errors.add(:note, "can't be longer than 500 graphemes")
+    end
+  end
+
   def normalize_domain
     return if local?
 
-- 
cgit 


From 3cac5bc2c3105ab0daab1e6892348d5be96d66a3 Mon Sep 17 00:00:00 2001
From: Surinna Curtis <ekiru.0@gmail.com>
Date: Sun, 10 Sep 2017 19:43:52 -0500
Subject: Fix a spuriously failing spec that assumed we required short bios
 like upstream

---
 app/models/account.rb                                           | 4 +++-
 spec/controllers/api/v1/accounts/credentials_controller_spec.rb | 4 +++-
 2 files changed, 6 insertions(+), 2 deletions(-)

(limited to 'app/models')

diff --git a/app/models/account.rb b/app/models/account.rb
index d0ebf5a5e..ac27c7923 100644
--- a/app/models/account.rb
+++ b/app/models/account.rb
@@ -54,6 +54,8 @@ class Account < ApplicationRecord
   include Remotable
   include EmojiHelper
 
+  MAX_NOTE_LENGTH = 500
+
   enum protocol: [:ostatus, :activitypub]
 
   # Local users
@@ -288,7 +290,7 @@ class Account < ApplicationRecord
         note_without_metadata = note[(idx + YAML_END.length) .. -1]
       end
     end
-    if note_without_metadata.mb_chars.grapheme_length > 500
+    if note_without_metadata.mb_chars.grapheme_length > MAX_NOTE_LENGTH
       errors.add(:note, "can't be longer than 500 graphemes")
     end
   end
diff --git a/spec/controllers/api/v1/accounts/credentials_controller_spec.rb b/spec/controllers/api/v1/accounts/credentials_controller_spec.rb
index 461b8b34b..247420d08 100644
--- a/spec/controllers/api/v1/accounts/credentials_controller_spec.rb
+++ b/spec/controllers/api/v1/accounts/credentials_controller_spec.rb
@@ -51,7 +51,9 @@ describe Api::V1::Accounts::CredentialsController do
 
       describe 'with invalid data' do
         before do
-          patch :update, params: { note: 'This is too long. ' * 10 }
+          note = 'This is too long. '
+          note = note + 'a' * (Account::MAX_NOTE_LENGTH - note.length + 1)
+          patch :update, params: { note: note }
         end
 
         it 'returns http unprocessable entity' do
-- 
cgit 


From 44207b6af6977f44200b6fd82f3e18ba70fd7cc7 Mon Sep 17 00:00:00 2001
From: Surinna Curtis <ekiru.0@gmail.com>
Date: Mon, 17 Jul 2017 21:10:37 -0500
Subject: Add muting_notifications? and a notifications argument to mute!

---
 app/models/concerns/account_interactions.rb |  8 ++++++--
 app/models/mute.rb                          | 11 ++++++-----
 db/schema.rb                                |  1 +
 3 files changed, 13 insertions(+), 7 deletions(-)

(limited to 'app/models')

diff --git a/app/models/concerns/account_interactions.rb b/app/models/concerns/account_interactions.rb
index b26520f5b..976452f12 100644
--- a/app/models/concerns/account_interactions.rb
+++ b/app/models/concerns/account_interactions.rb
@@ -70,8 +70,8 @@ module AccountInteractions
     block_relationships.find_or_create_by!(target_account: other_account)
   end
 
-  def mute!(other_account)
-    mute_relationships.find_or_create_by!(target_account: other_account)
+  def mute!(other_account, notifications: true)
+    mute_relationships.create_with(hide_notifications: notifications).find_or_create_by!(target_account: other_account)
   end
 
   def mute_conversation!(conversation)
@@ -127,6 +127,10 @@ module AccountInteractions
     conversation_mutes.where(conversation: conversation).exists?
   end
 
+  def muting_notifications?(other_account)
+    mute_relationships.where(target_account: other_account, hide_notifications: true).exists?
+  end
+
   def requested?(other_account)
     follow_requests.where(target_account: other_account).exists?
   end
diff --git a/app/models/mute.rb b/app/models/mute.rb
index 00e5661a7..40fb3f0f2 100644
--- a/app/models/mute.rb
+++ b/app/models/mute.rb
@@ -3,11 +3,12 @@
 #
 # Table name: mutes
 #
-#  id                :integer          not null, primary key
-#  account_id        :integer          not null
-#  target_account_id :integer          not null
-#  created_at        :datetime         not null
-#  updated_at        :datetime         not null
+#  id                 :integer          not null, primary key
+#  account_id         :integer          not null
+#  target_account_id  :integer          not null
+#  created_at         :datetime         not null
+#  updated_at         :datetime         not null
+#  hide_notifications :boolean          default(FALSE), not null
 #
 
 class Mute < ApplicationRecord
diff --git a/db/schema.rb b/db/schema.rb
index d8af0a1f8..90f6fb1b3 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -168,6 +168,7 @@ ActiveRecord::Schema.define(version: 20170905165803) do
     t.integer "target_account_id", null: false
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
+    t.boolean "hide_notifications", default: false, null: false
     t.index ["account_id", "target_account_id"], name: "index_mutes_on_account_id_and_target_account_id", unique: true
   end
 
-- 
cgit 


From 7dbcc7ed3df9ed858ebdd44607d2baa0b2939b4c Mon Sep 17 00:00:00 2001
From: Surinna Curtis <ekiru.0@gmail.com>
Date: Sat, 9 Sep 2017 05:05:43 -0500
Subject: Expose whether a mute hides notifications in the api/v1/relationships
 endpoint

---
 app/models/concerns/account_interactions.rb | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'app/models')

diff --git a/app/models/concerns/account_interactions.rb b/app/models/concerns/account_interactions.rb
index 976452f12..c258bfbfc 100644
--- a/app/models/concerns/account_interactions.rb
+++ b/app/models/concerns/account_interactions.rb
@@ -17,7 +17,11 @@ module AccountInteractions
     end
 
     def muting_map(target_account_ids, account_id)
-      follow_mapping(Mute.where(target_account_id: target_account_ids, account_id: account_id), :target_account_id)
+      Mute.where(target_account_id: target_account_ids, account_id: account_id).each_with_object({}) do |mute, mapping|
+        mapping[mute.target_account_id] = {
+          notifications: mute.hide_notifications?
+        }
+      end
     end
 
     def requested_map(target_account_ids, account_id)
-- 
cgit 


From 0284fd723b4d45ab2b381ee0c4f6550f44d3abf5 Mon Sep 17 00:00:00 2001
From: Surinna Curtis <ekiru.0@gmail.com>
Date: Sat, 9 Sep 2017 05:16:06 -0500
Subject: Allow modifying the hide_notifications of a mute with the
 /api/v1/accounts/:id/mute endpoint

---
 app/models/concerns/account_interactions.rb | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'app/models')

diff --git a/app/models/concerns/account_interactions.rb b/app/models/concerns/account_interactions.rb
index c258bfbfc..4a4265df2 100644
--- a/app/models/concerns/account_interactions.rb
+++ b/app/models/concerns/account_interactions.rb
@@ -75,7 +75,11 @@ module AccountInteractions
   end
 
   def mute!(other_account, notifications: true)
-    mute_relationships.create_with(hide_notifications: notifications).find_or_create_by!(target_account: other_account)
+    mute = mute_relationships.create_with(hide_notifications: notifications).find_or_create_by!(target_account: other_account)
+    if mute.hide_notifications? != notifications
+      mute.hide_notifications = notifications
+      mute.save!
+    end
   end
 
   def mute_conversation!(conversation)
-- 
cgit 


From 211f0a951375a33ed4278eef030e76a6bde9c396 Mon Sep 17 00:00:00 2001
From: Surinna Curtis <ekiru.0@gmail.com>
Date: Wed, 13 Sep 2017 17:42:52 -0500
Subject: add an explanatory comment to AccountInteractions

---
 app/models/concerns/account_interactions.rb | 1 +
 1 file changed, 1 insertion(+)

(limited to 'app/models')

diff --git a/app/models/concerns/account_interactions.rb b/app/models/concerns/account_interactions.rb
index 4a4265df2..6f69ce1d4 100644
--- a/app/models/concerns/account_interactions.rb
+++ b/app/models/concerns/account_interactions.rb
@@ -76,6 +76,7 @@ module AccountInteractions
 
   def mute!(other_account, notifications: true)
     mute = mute_relationships.create_with(hide_notifications: notifications).find_or_create_by!(target_account: other_account)
+    # When toggling a mute between hiding and allowing notifications, the mute will already exist, so the find_or_create_by! call will return the existing Mute without updating the hide_notifications attribute. Therefore, we check that hide_notifications? is what we want and set it if it isn't.
     if mute.hide_notifications? != notifications
       mute.hide_notifications = notifications
       mute.save!
-- 
cgit 


From f9d7b8a94f4a89d76081a6265103f6d7439be250 Mon Sep 17 00:00:00 2001
From: Surinna Curtis <ekiru.0@gmail.com>
Date: Wed, 13 Sep 2017 18:32:10 -0500
Subject: Refactor handling of default params for muting to make code cleaner

---
 app/controllers/api/v1/accounts_controller.rb | 2 +-
 app/models/concerns/account_interactions.rb   | 3 ++-
 app/services/mute_service.rb                  | 4 ++--
 3 files changed, 5 insertions(+), 4 deletions(-)

(limited to 'app/models')

diff --git a/app/controllers/api/v1/accounts_controller.rb b/app/controllers/api/v1/accounts_controller.rb
index de2cb0d97..3e9ac1025 100644
--- a/app/controllers/api/v1/accounts_controller.rb
+++ b/app/controllers/api/v1/accounts_controller.rb
@@ -33,7 +33,7 @@ class Api::V1::AccountsController < Api::BaseController
   end
 
   def mute
-    MuteService.new.call(current_user.account, @account, **params.permit(:notifications).to_hash.symbolize_keys)
+    MuteService.new.call(current_user.account, @account, notifications: params(:notifications))
     render json: @account, serializer: REST::RelationshipSerializer, relationships: relationships
   end
 
diff --git a/app/models/concerns/account_interactions.rb b/app/models/concerns/account_interactions.rb
index 6f69ce1d4..0afdebf89 100644
--- a/app/models/concerns/account_interactions.rb
+++ b/app/models/concerns/account_interactions.rb
@@ -74,7 +74,8 @@ module AccountInteractions
     block_relationships.find_or_create_by!(target_account: other_account)
   end
 
-  def mute!(other_account, notifications: true)
+  def mute!(other_account, notifications: nil)
+    notifications = true if notifications.nil?
     mute = mute_relationships.create_with(hide_notifications: notifications).find_or_create_by!(target_account: other_account)
     # When toggling a mute between hiding and allowing notifications, the mute will already exist, so the find_or_create_by! call will return the existing Mute without updating the hide_notifications attribute. Therefore, we check that hide_notifications? is what we want and set it if it isn't.
     if mute.hide_notifications? != notifications
diff --git a/app/services/mute_service.rb b/app/services/mute_service.rb
index fc63f83e9..56cbebd5d 100644
--- a/app/services/mute_service.rb
+++ b/app/services/mute_service.rb
@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 class MuteService < BaseService
-  def call(account, target_account, **opts)
+  def call(account, target_account, notifications: nil)
     return if account.id == target_account.id
     FeedManager.instance.clear_from_timeline(account, target_account)
-    account.mute!(target_account, **opts.slice(:notifications))
+    account.mute!(target_account, notifications: notifications)
   end
 end
-- 
cgit 


From fd9a1711296d923c56a3954fd691e01b54ee93e5 Mon Sep 17 00:00:00 2001
From: Surinna Curtis <ekiru.0@gmail.com>
Date: Wed, 13 Sep 2017 22:35:48 -0500
Subject: fix typos in the migration

---
 app/models/mute.rb                                                    | 2 +-
 .../20170914032032_default_existing_mutes_to_hiding_notifications.rb  | 4 ++--
 db/schema.rb                                                          | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'app/models')

diff --git a/app/models/mute.rb b/app/models/mute.rb
index 40fb3f0f2..0d597a275 100644
--- a/app/models/mute.rb
+++ b/app/models/mute.rb
@@ -8,7 +8,7 @@
 #  target_account_id  :integer          not null
 #  created_at         :datetime         not null
 #  updated_at         :datetime         not null
-#  hide_notifications :boolean          default(FALSE), not null
+#  hide_notifications :boolean          default(TRUE), not null
 #
 
 class Mute < ApplicationRecord
diff --git a/db/migrate/20170914032032_default_existing_mutes_to_hiding_notifications.rb b/db/migrate/20170914032032_default_existing_mutes_to_hiding_notifications.rb
index e7818f8c3..8e6cac455 100644
--- a/db/migrate/20170914032032_default_existing_mutes_to_hiding_notifications.rb
+++ b/db/migrate/20170914032032_default_existing_mutes_to_hiding_notifications.rb
@@ -1,8 +1,8 @@
 class DefaultExistingMutesToHidingNotifications < ActiveRecord::Migration[5.1]
   def up
-    t.change_column_default :mutes, :hide_notifications, from: false, to: true
+    change_column_default :mutes, :hide_notifications, from: false, to: true
 
     # Unfortunately if this is applied sometime after the one to add the table we lose some data, so this is irreversible.
-    Mutes.update_all(hide_notifications: true)
+    Mute.update_all(hide_notifications: true)
   end
 end
diff --git a/db/schema.rb b/db/schema.rb
index 90f6fb1b3..52edfa497 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20170905165803) do
+ActiveRecord::Schema.define(version: 20170914032032) do
 
   # These are extensions that must be enabled in order to support this database
   enable_extension "plpgsql"
@@ -168,7 +168,7 @@ ActiveRecord::Schema.define(version: 20170905165803) do
     t.integer "target_account_id", null: false
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
-    t.boolean "hide_notifications", default: false, null: false
+    t.boolean "hide_notifications", default: true, null: false
     t.index ["account_id", "target_account_id"], name: "index_mutes_on_account_id_and_target_account_id", unique: true
   end
 
-- 
cgit 


From 86e617a839bd4eb45ace52ab226a4e93bb184ff0 Mon Sep 17 00:00:00 2001
From: kibigo! <marrus-sh@users.noreply.github.com>
Date: Mon, 25 Sep 2017 19:24:32 -0700
Subject: Better themeing support!!

---
 app/controllers/application_controller.rb          |  6 ++++
 app/controllers/settings/preferences_controller.rb |  1 +
 .../local_settings/navigation/item/style.scss      |  2 +-
 .../local_settings/navigation/style.scss           |  2 +-
 .../components/local_settings/page/item/style.scss |  2 +-
 .../components/local_settings/page/style.scss      |  2 +-
 .../glitch/components/local_settings/style.scss    |  2 +-
 app/javascript/packs/application.js                |  2 +-
 app/javascript/packs/frontends/mastodon.js         | 16 ----------
 app/javascript/styles/custom.scss                  |  1 -
 app/javascript/themes/default/theme.yml            |  9 ++++++
 app/javascript/themes/spin/pack.js                 |  2 ++
 app/javascript/themes/spin/style.scss              | 14 ++++++++
 app/javascript/themes/spin/theme.yml               |  2 ++
 app/lib/themes.rb                                  | 23 ++++++++++++++
 app/lib/user_settings_decorator.rb                 |  5 +++
 app/models/user.rb                                 |  4 +++
 app/views/home/index.html.haml                     |  4 +--
 app/views/settings/preferences/show.html.haml      |  2 ++
 config/initializers/frontends.rb                   |  7 ----
 config/locales/simple_form.en.yml                  |  2 ++
 config/settings.yml                                |  1 +
 config/webpack/configuration.js                    | 17 +++++++++-
 config/webpack/loaders/sass.js                     |  2 +-
 config/webpack/shared.js                           | 37 ++++++++++++----------
 25 files changed, 117 insertions(+), 50 deletions(-)
 delete mode 100644 app/javascript/packs/frontends/mastodon.js
 delete mode 100644 app/javascript/styles/custom.scss
 create mode 100644 app/javascript/themes/default/theme.yml
 create mode 100644 app/javascript/themes/spin/pack.js
 create mode 100644 app/javascript/themes/spin/style.scss
 create mode 100644 app/javascript/themes/spin/theme.yml
 create mode 100644 app/lib/themes.rb
 delete mode 100644 config/initializers/frontends.rb

(limited to 'app/models')

diff --git a/app/controllers/application_controller.rb b/app/controllers/application_controller.rb
index 0b40fb05b..d5eca6ffb 100644
--- a/app/controllers/application_controller.rb
+++ b/app/controllers/application_controller.rb
@@ -12,6 +12,7 @@ class ApplicationController < ActionController::Base
 
   helper_method :current_account
   helper_method :current_session
+  helper_method :current_theme
   helper_method :single_user_mode?
 
   rescue_from ActionController::RoutingError, with: :not_found
@@ -77,6 +78,11 @@ class ApplicationController < ActionController::Base
     @current_session ||= SessionActivation.find_by(session_id: cookies.signed['_session_id'])
   end
 
+  def current_theme
+    return Setting.default_settings['theme'] unless Themes.instance.names.include? current_user&.setting_theme
+    current_user.setting_theme
+  end
+
   def cache_collection(raw, klass)
     return raw unless klass.respond_to?(:with_includes)
 
diff --git a/app/controllers/settings/preferences_controller.rb b/app/controllers/settings/preferences_controller.rb
index f107f2b16..207c7b324 100644
--- a/app/controllers/settings/preferences_controller.rb
+++ b/app/controllers/settings/preferences_controller.rb
@@ -41,6 +41,7 @@ class Settings::PreferencesController < ApplicationController
       :setting_auto_play_gif,
       :setting_system_font_ui,
       :setting_noindex,
+      :setting_theme,
       notification_emails: %i(follow follow_request reblog favourite mention digest),
       interactions: %i(must_be_follower must_be_following)
     )
diff --git a/app/javascript/glitch/components/local_settings/navigation/item/style.scss b/app/javascript/glitch/components/local_settings/navigation/item/style.scss
index 505c86912..33d7d3744 100644
--- a/app/javascript/glitch/components/local_settings/navigation/item/style.scss
+++ b/app/javascript/glitch/components/local_settings/navigation/item/style.scss
@@ -1,4 +1,4 @@
-@import 'variables';
+@import 'styles/variables';
 
 .glitch.local-settings__navigation__item {
   display: block;
diff --git a/app/javascript/glitch/components/local_settings/navigation/style.scss b/app/javascript/glitch/components/local_settings/navigation/style.scss
index 1cc39e3e9..a610a1212 100644
--- a/app/javascript/glitch/components/local_settings/navigation/style.scss
+++ b/app/javascript/glitch/components/local_settings/navigation/style.scss
@@ -1,4 +1,4 @@
-@import 'variables';
+@import 'styles/variables';
 
 .glitch.local-settings__navigation {
   background: $primary-text-color;
diff --git a/app/javascript/glitch/components/local_settings/page/item/style.scss b/app/javascript/glitch/components/local_settings/page/item/style.scss
index e614030c0..da1941b99 100644
--- a/app/javascript/glitch/components/local_settings/page/item/style.scss
+++ b/app/javascript/glitch/components/local_settings/page/item/style.scss
@@ -1,4 +1,4 @@
-@import 'variables';
+@import 'styles/variables';
 
 .glitch.local-settings__page__item {
   select {
diff --git a/app/javascript/glitch/components/local_settings/page/style.scss b/app/javascript/glitch/components/local_settings/page/style.scss
index 7269056c3..53c95ea40 100644
--- a/app/javascript/glitch/components/local_settings/page/style.scss
+++ b/app/javascript/glitch/components/local_settings/page/style.scss
@@ -1,4 +1,4 @@
-@import 'variables';
+@import 'styles/variables';
 
 .glitch.local-settings__page {
   display: block;
diff --git a/app/javascript/glitch/components/local_settings/style.scss b/app/javascript/glitch/components/local_settings/style.scss
index 6f7fcbaa4..54fec47bd 100644
--- a/app/javascript/glitch/components/local_settings/style.scss
+++ b/app/javascript/glitch/components/local_settings/style.scss
@@ -1,4 +1,4 @@
-@import 'variables';
+@import 'styles/variables';
 
 .glitch.local-settings {
   position: relative;
diff --git a/app/javascript/packs/application.js b/app/javascript/packs/application.js
index c06714dc1..aa94006c6 100644
--- a/app/javascript/packs/application.js
+++ b/app/javascript/packs/application.js
@@ -2,7 +2,7 @@ import loadPolyfills from '../mastodon/load_polyfills';
 
 // import default stylesheet with variables
 require('font-awesome/css/font-awesome.css');
-require('mastodon-application-style');
+import 'styles/application';
 
 require.context('../images/', true);
 
diff --git a/app/javascript/packs/frontends/mastodon.js b/app/javascript/packs/frontends/mastodon.js
deleted file mode 100644
index a983de36f..000000000
--- a/app/javascript/packs/frontends/mastodon.js
+++ /dev/null
@@ -1,16 +0,0 @@
-// This file replaces `app/javascript/packs/application.js` for use
-// with multiple frontends.
-
-import loadPolyfills from '../../mastodon/load_polyfills';
-
-// import default stylesheet with variables
-require('font-awesome/css/font-awesome.css');
-require('mastodon-application-style');
-
-require.context('../../images/', true);
-
-loadPolyfills().then(() => {
-  require('../../mastodon/main').default();
-}).catch(e => {
-  console.error(e);
-});
diff --git a/app/javascript/styles/custom.scss b/app/javascript/styles/custom.scss
deleted file mode 100644
index 97a981243..000000000
--- a/app/javascript/styles/custom.scss
+++ /dev/null
@@ -1 +0,0 @@
-@import 'application';
diff --git a/app/javascript/themes/default/theme.yml b/app/javascript/themes/default/theme.yml
new file mode 100644
index 000000000..6a7a872b4
--- /dev/null
+++ b/app/javascript/themes/default/theme.yml
@@ -0,0 +1,9 @@
+#  (REQUIRED) Name must be unique across all installed themes.
+name: default
+
+#  (REQUIRED) The location of the pack file inside `pack_directory`.
+pack: application.js
+
+#  (OPTIONAL) The directory which contains the pack file.
+#  Defaults to the theme directory (`app/javascript/themes/[theme]`).
+pack_directory: app/javascript/packs
diff --git a/app/javascript/themes/spin/pack.js b/app/javascript/themes/spin/pack.js
new file mode 100644
index 000000000..dab0e93a4
--- /dev/null
+++ b/app/javascript/themes/spin/pack.js
@@ -0,0 +1,2 @@
+import 'packs/application';
+import 'themes/spin/style';
diff --git a/app/javascript/themes/spin/style.scss b/app/javascript/themes/spin/style.scss
new file mode 100644
index 000000000..1a9381fd0
--- /dev/null
+++ b/app/javascript/themes/spin/style.scss
@@ -0,0 +1,14 @@
+:root:root:root {
+  .button, .icon-button, .emoji-button, .account__avatar, .account__avatar-overlay {
+    animation: spin 4s linear infinite;
+  }
+}
+
+@keyframes spin {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}
diff --git a/app/javascript/themes/spin/theme.yml b/app/javascript/themes/spin/theme.yml
new file mode 100644
index 000000000..a684997dc
--- /dev/null
+++ b/app/javascript/themes/spin/theme.yml
@@ -0,0 +1,2 @@
+name: spin
+pack: pack.js
\ No newline at end of file
diff --git a/app/lib/themes.rb b/app/lib/themes.rb
new file mode 100644
index 000000000..2dd188297
--- /dev/null
+++ b/app/lib/themes.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'yaml'
+
+class Themes
+  include Singleton
+
+  def initialize
+    result = Hash.new
+    Dir.glob(Rails.root.join('app', 'javascript', 'themes', '*', 'theme.yml')) do |path|
+      data = YAML.load_file(path)
+      if data['pack'] && data['name']
+        result[data['name']] = data
+      end
+    end
+    @conf = result
+  end
+
+  def names
+    @conf.keys
+  end
+end
diff --git a/app/lib/user_settings_decorator.rb b/app/lib/user_settings_decorator.rb
index 62046ed72..3b156b98c 100644
--- a/app/lib/user_settings_decorator.rb
+++ b/app/lib/user_settings_decorator.rb
@@ -25,6 +25,7 @@ class UserSettingsDecorator
     user.settings['auto_play_gif'] = auto_play_gif_preference
     user.settings['system_font_ui'] = system_font_ui_preference
     user.settings['noindex'] = noindex_preference
+    user.settings['theme'] = theme_preference
   end
 
   def merged_notification_emails
@@ -67,6 +68,10 @@ class UserSettingsDecorator
     boolean_cast_setting 'setting_noindex'
   end
 
+  def theme_preference
+    settings['setting_theme']
+  end
+  
   def boolean_cast_setting(key)
     settings[key] == '1'
   end
diff --git a/app/models/user.rb b/app/models/user.rb
index 5e548c1ef..3bf069a31 100644
--- a/app/models/user.rb
+++ b/app/models/user.rb
@@ -110,6 +110,10 @@ class User < ApplicationRecord
     settings.noindex
   end
 
+  def setting_theme
+    settings.theme
+  end
+
   def token_for_app(a)
     return nil if a.nil? || a.owner != self
     Doorkeeper::AccessToken
diff --git a/app/views/home/index.html.haml b/app/views/home/index.html.haml
index a13d0702b..3b4219c56 100644
--- a/app/views/home/index.html.haml
+++ b/app/views/home/index.html.haml
@@ -2,8 +2,8 @@
   %meta{name: 'applicationServerKey', content: Rails.configuration.x.vapid_public_key}
   %script#initial-state{ type: 'application/json' }!= json_escape(@initial_state_json)
 
-  = javascript_pack_tag "frontends/#{@frontend}", integrity: true, crossorigin: 'anonymous'
-  = stylesheet_pack_tag "frontends/#{@frontend}", integrity: true, media: 'all'
+  = javascript_pack_tag "themes/#{current_theme}", integrity: true, crossorigin: 'anonymous'
+  = stylesheet_pack_tag "themes/#{current_theme}", integrity: true, media: 'all'
 
 .app-holder#mastodon{ data: { props: Oj.dump(default_props) } }
   %noscript
diff --git a/app/views/settings/preferences/show.html.haml b/app/views/settings/preferences/show.html.haml
index f42f92508..5efd538e4 100644
--- a/app/views/settings/preferences/show.html.haml
+++ b/app/views/settings/preferences/show.html.haml
@@ -5,6 +5,8 @@
   = render 'shared/error_messages', object: current_user
 
   .fields-group
+    = f.input :setting_theme, collection: Themes.instance.names, label_method: lambda { |theme| safe_join([I18n.t("themes.#{theme}", default: theme)])}, wrapper: :with_label, include_blank: false
+
     = f.input :locale,
       collection: I18n.available_locales,
       wrapper: :with_label,
diff --git a/config/initializers/frontends.rb b/config/initializers/frontends.rb
deleted file mode 100644
index 2cb68cc61..000000000
--- a/config/initializers/frontends.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-# Be sure to restart your server when you modify this file.
-
-Rails.application.configure do
-  frontends = []
-  Rails.root.join('app', 'javascript', 'packs', 'frontends').each_child(false) { |f| frontends.push f.to_s }
-  config.x.available_frontends = frontends
-end
diff --git a/config/locales/simple_form.en.yml b/config/locales/simple_form.en.yml
index fb8524a24..f9d4e2e52 100644
--- a/config/locales/simple_form.en.yml
+++ b/config/locales/simple_form.en.yml
@@ -13,6 +13,7 @@ en:
           one: <span class="note-counter">1</span> character left
           other: <span class="note-counter">%{count}</span> characters left
         setting_noindex: Affects your public profile and status pages
+        setting_theme: Affects how Mastodon looks when you're logged in from any device.
       imports:
         data: CSV file exported from another Mastodon instance
       sessions:
@@ -44,6 +45,7 @@ en:
         setting_noindex: Opt-out of search engine indexing
         setting_system_font_ui: Use system's default font
         setting_unfollow_modal: Show confirmation dialog before unfollowing someone
+        setting_theme: Site theme
         severity: Severity
         type: Import type
         username: Username
diff --git a/config/settings.yml b/config/settings.yml
index 39dfb8f55..3cd3307f4 100644
--- a/config/settings.yml
+++ b/config/settings.yml
@@ -24,6 +24,7 @@ defaults: &defaults
   auto_play_gif: false
   system_font_ui: false
   noindex: false
+  theme: 'default'
   notification_emails:
     follow: false
     reblog: false
diff --git a/config/webpack/configuration.js b/config/webpack/configuration.js
index 6ef484c3a..606eb97f1 100644
--- a/config/webpack/configuration.js
+++ b/config/webpack/configuration.js
@@ -1,13 +1,27 @@
 // Common configuration for webpacker loaded from config/webpacker.yml
 
-const { join, resolve } = require('path');
+const { dirname, join, resolve } = require('path');
 const { env } = require('process');
 const { safeLoad } = require('js-yaml');
 const { readFileSync } = require('fs');
+const glob = require('glob');
 
 const configPath = resolve('config', 'webpacker.yml');
 const loadersDir = join(__dirname, 'loaders');
 const settings = safeLoad(readFileSync(configPath), 'utf8')[env.NODE_ENV];
+const themeFiles = glob.sync('app/javascript/themes/*/theme.yml');
+const themes = {};
+
+for (let i = 0; i < themeFiles.length; i++) {
+  const themeFile = themeFiles[i];
+  const data = safeLoad(readFileSync(themeFile), 'utf8');
+  if (!data.pack_directory) {
+    data.pack_directory = dirname(themeFile);
+  }
+  if (data.name && data.pack) {
+    themes[data.name] = data;
+  }
+}
 
 function removeOuterSlashes(string) {
   return string.replace(/^\/*/, '').replace(/\/*$/, '');
@@ -29,6 +43,7 @@ const output = {
 
 module.exports = {
   settings,
+  themes,
   env,
   loadersDir,
   output,
diff --git a/config/webpack/loaders/sass.js b/config/webpack/loaders/sass.js
index 40e81b43b..96ad7abe8 100644
--- a/config/webpack/loaders/sass.js
+++ b/config/webpack/loaders/sass.js
@@ -9,7 +9,7 @@ module.exports = {
       { loader: 'css-loader', options: { minimize: env.NODE_ENV === 'production' } },
       { loader: 'postcss-loader', options: { sourceMap: true } },
       'resolve-url-loader',
-      { loader: 'sass-loader', options: { includePaths: ['app/javascript/styles'] } },
+      { loader: 'sass-loader', options: { includePaths: ['app/javascript'] } },
     ],
   }),
 };
diff --git a/config/webpack/shared.js b/config/webpack/shared.js
index be1b49421..ab925b020 100644
--- a/config/webpack/shared.js
+++ b/config/webpack/shared.js
@@ -1,13 +1,12 @@
 // Note: You must restart bin/webpack-dev-server for changes to take effect
 
-const { existsSync } = require('fs');
 const webpack = require('webpack');
 const { basename, dirname, join, relative, resolve } = require('path');
 const { sync } = require('glob');
 const ExtractTextPlugin = require('extract-text-webpack-plugin');
 const ManifestPlugin = require('webpack-manifest-plugin');
 const extname = require('path-complete-extname');
-const { env, settings, output, loadersDir } = require('./configuration.js');
+const { env, settings, themes, output, loadersDir } = require('./configuration.js');
 const localePackPaths = require('./generateLocalePacks');
 
 const extensionGlob = `**/*{${settings.extensions.join(',')}}*`;
@@ -18,17 +17,27 @@ const entryPacks = [...packPaths, ...localePackPaths].filter(path => path !== jo
 const customApplicationStyle = resolve(join(settings.source_path, 'styles/custom.scss'));
 const originalApplicationStyle = resolve(join(settings.source_path, 'styles/application.scss'));
 
+const themePaths = Object.keys(themes).reduce(
+  (themePaths, name) => {
+    themeData = themes[name];
+    themePaths[`themes/${name}`] = resolve(themeData.pack_directory, themeData.pack);
+    return themePaths;
+  }, {}
+);
+
 module.exports = {
-  entry: entryPacks.reduce(
-    (map, entry) => {
-      const localMap = map;
-      let namespace = relative(join(entryPath), dirname(entry));
-      if (namespace === join('..', '..', '..', 'tmp', 'packs')) {
-        namespace = ''; // generated by generateLocalePacks.js
-      }
-      localMap[join(namespace, basename(entry, extname(entry)))] = resolve(entry);
-      return localMap;
-    }, {}
+  entry: Object.assign(
+    entryPacks.reduce(
+      (map, entry) => {
+        const localMap = map;
+        let namespace = relative(join(entryPath), dirname(entry));
+        if (namespace === join('..', '..', '..', 'tmp', 'packs')) {
+          namespace = ''; // generated by generateLocalePacks.js
+        }
+        localMap[join(namespace, basename(entry, extname(entry)))] = resolve(entry);
+        return localMap;
+      }, {}
+    ), themePaths
   ),
 
   output: {
@@ -59,10 +68,6 @@ module.exports = {
   ],
 
   resolve: {
-    alias: {
-      'mastodon-application-style': existsSync(customApplicationStyle) ?
-                                    customApplicationStyle : originalApplicationStyle,
-    },
     extensions: settings.extensions,
     modules: [
       resolve(settings.source_path),
-- 
cgit 


From 96ba3482b96504d7a8e2a7dc7dbfea41c86be74f Mon Sep 17 00:00:00 2001
From: DJ Sundog <djsundog@gmail.com>
Date: Sat, 7 Oct 2017 19:54:10 +0000
Subject: adding support for audio uploads, transcoded to mp4 videos

---
 app/models/media_attachment.rb              | 28 ++++++++++++++++++++++++----
 app/serializers/initial_state_serializer.rb |  2 +-
 config/application.rb                       |  1 +
 lib/paperclip/audio_transcoder.rb           | 15 +++++++++++++++
 4 files changed, 41 insertions(+), 5 deletions(-)
 create mode 100644 lib/paperclip/audio_transcoder.rb

(limited to 'app/models')

diff --git a/app/models/media_attachment.rb b/app/models/media_attachment.rb
index e4a974f96..93ff43d58 100644
--- a/app/models/media_attachment.rb
+++ b/app/models/media_attachment.rb
@@ -23,15 +23,31 @@ require 'mime/types'
 class MediaAttachment < ApplicationRecord
   self.inheritance_column = nil
 
-  enum type: [:image, :gifv, :video, :unknown]
+  enum type: [:image, :gifv, :video, :audio, :unknown]
 
   IMAGE_FILE_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.gif'].freeze
   VIDEO_FILE_EXTENSIONS = ['.webm', '.mp4', '.m4v'].freeze
+  AUDIO_FILE_EXTENSIONS = ['.mp3', '.m4a', '.wav', '.ogg'].freeze
 
   IMAGE_MIME_TYPES = ['image/jpeg', 'image/png', 'image/gif'].freeze
   VIDEO_MIME_TYPES = ['video/webm', 'video/mp4'].freeze
+  AUDIO_MIME_TYPES = ['audio/mpeg', 'audio/mp4', 'audio/vnd.wav', 'audio/wav', 'audio/x-wav', 'audio/x-wave', 'audio/ogg',].freeze
 
   IMAGE_STYLES = { original: '1280x1280>', small: '400x400>' }.freeze
+  AUDIO_STYLES = {
+    original: {
+        format: 'mp4',
+        convert_options: {
+            output: {
+                filter_complex: '"[0:a]compand,showwaves=s=640x360:mode=line,format=yuv420p[v]"',
+                map: '"[v]" -map 0:a', 
+                threads: 2,
+                vcodec: 'libx264',
+                acodec: 'aac',
+            },
+        },
+    },
+  }.freeze
   VIDEO_STYLES = {
     small: {
       convert_options: {
@@ -54,7 +70,7 @@ class MediaAttachment < ApplicationRecord
 
   include Remotable
 
-  validates_attachment_content_type :file, content_type: IMAGE_MIME_TYPES + VIDEO_MIME_TYPES
+  validates_attachment_content_type :file, content_type: IMAGE_MIME_TYPES + VIDEO_MIME_TYPES + AUDIO_MIME_TYPES
   validates_attachment_size :file, less_than: 8.megabytes
 
   validates :account, presence: true
@@ -107,6 +123,8 @@ class MediaAttachment < ApplicationRecord
         }
       elsif IMAGE_MIME_TYPES.include? f.instance.file_content_type
         IMAGE_STYLES
+      elsif AUDIO_MIME_TYPES.include? f.instance.file_content_type
+        AUDIO_STYLES
       else
         VIDEO_STYLES
       end
@@ -117,6 +135,8 @@ class MediaAttachment < ApplicationRecord
         [:gif_transcoder]
       elsif VIDEO_MIME_TYPES.include? f.file_content_type
         [:video_transcoder]
+      elsif AUDIO_MIME_TYPES.include? f.file_content_type
+        [:audio_transcoder]
       else
         [:thumbnail]
       end
@@ -137,8 +157,8 @@ class MediaAttachment < ApplicationRecord
   end
 
   def set_type_and_extension
-    self.type = VIDEO_MIME_TYPES.include?(file_content_type) ? :video : :image
-    extension = appropriate_extension
+    self.type = VIDEO_MIME_TYPES.include?(file_content_type) ? :video : AUDIO_MIME_TYPES.include?(file_content_type) ? :audio : :image
+    extension = AUDIO_MIME_TYPES.include?(file_content_type) ? '.mp4' : appropriate_extension
     basename  = Paperclip::Interpolations.basename(file, :original)
     file.instance_write :file_name, [basename, extension].delete_if(&:blank?).join('.')
   end
diff --git a/app/serializers/initial_state_serializer.rb b/app/serializers/initial_state_serializer.rb
index e2f15a601..0992771fc 100644
--- a/app/serializers/initial_state_serializer.rb
+++ b/app/serializers/initial_state_serializer.rb
@@ -52,6 +52,6 @@ class InitialStateSerializer < ActiveModel::Serializer
   end
 
   def media_attachments
-    { accept_content_types: MediaAttachment::IMAGE_FILE_EXTENSIONS + MediaAttachment::VIDEO_FILE_EXTENSIONS + MediaAttachment::IMAGE_MIME_TYPES + MediaAttachment::VIDEO_MIME_TYPES }
+    { accept_content_types: MediaAttachment::IMAGE_FILE_EXTENSIONS + MediaAttachment::VIDEO_FILE_EXTENSIONS + MediaAttachment::AUDIO_FILE_EXTENSIONS + MediaAttachment::IMAGE_MIME_TYPES + MediaAttachment::VIDEO_MIME_TYPES + MediaAttachment::AUDIO_MIME_TYPES }
   end
 end
diff --git a/config/application.rb b/config/application.rb
index eb89f0a10..db53b8c84 100644
--- a/config/application.rb
+++ b/config/application.rb
@@ -9,6 +9,7 @@ Bundler.require(*Rails.groups)
 require_relative '../app/lib/exceptions'
 require_relative '../lib/paperclip/gif_transcoder'
 require_relative '../lib/paperclip/video_transcoder'
+require_relative '../lib/paperclip/audio_transcoder'
 require_relative '../lib/mastodon/version'
 
 Dotenv::Railtie.load
diff --git a/lib/paperclip/audio_transcoder.rb b/lib/paperclip/audio_transcoder.rb
new file mode 100644
index 000000000..484d694d7
--- /dev/null
+++ b/lib/paperclip/audio_transcoder.rb
@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Paperclip
+  class AudioTranscoder < Paperclip::Processor
+    def make
+       final_file = Paperclip::Transcoder.make(file, options, attachment)
+
+       attachment.instance.file_file_name    = 'media.mp4'
+       attachment.instance.file_content_type = 'video/mp4'
+       attachment.instance.type              = MediaAttachment.types[:video]
+
+       final_file
+    end
+  end
+end
-- 
cgit 


From 6ca03a7f5861bf03e00f86342409711e078e1131 Mon Sep 17 00:00:00 2001
From: DJ Sundog <djsundog@gmail.com>
Date: Sat, 7 Oct 2017 19:59:22 +0000
Subject: add faststart to audio transcoding

---
 app/models/media_attachment.rb | 1 +
 1 file changed, 1 insertion(+)

(limited to 'app/models')

diff --git a/app/models/media_attachment.rb b/app/models/media_attachment.rb
index 93ff43d58..1bea8c872 100644
--- a/app/models/media_attachment.rb
+++ b/app/models/media_attachment.rb
@@ -44,6 +44,7 @@ class MediaAttachment < ApplicationRecord
                 threads: 2,
                 vcodec: 'libx264',
                 acodec: 'aac',
+                movflags: '+faststart',
             },
         },
     },
-- 
cgit 


From 979b0d66a7e0a49646b396c2486a762a9bb57a05 Mon Sep 17 00:00:00 2001
From: DJ Sundog <sundog@reclaim.technology>
Date: Sat, 7 Oct 2017 13:53:46 -0700
Subject: update indentation

---
 app/models/media_attachment.rb | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'app/models')

diff --git a/app/models/media_attachment.rb b/app/models/media_attachment.rb
index 1bea8c872..65ff893a8 100644
--- a/app/models/media_attachment.rb
+++ b/app/models/media_attachment.rb
@@ -36,17 +36,17 @@ class MediaAttachment < ApplicationRecord
   IMAGE_STYLES = { original: '1280x1280>', small: '400x400>' }.freeze
   AUDIO_STYLES = {
     original: {
-        format: 'mp4',
-        convert_options: {
-            output: {
-                filter_complex: '"[0:a]compand,showwaves=s=640x360:mode=line,format=yuv420p[v]"',
-                map: '"[v]" -map 0:a', 
-                threads: 2,
-                vcodec: 'libx264',
-                acodec: 'aac',
-                movflags: '+faststart',
-            },
+      format: 'mp4',
+      convert_options: {
+        output: {
+          filter_complex: '"[0:a]compand,showwaves=s=640x360:mode=line,format=yuv420p[v]"',
+          map: '"[v]" -map 0:a', 
+          threads: 2,
+          vcodec: 'libx264',
+          acodec: 'aac',
+          movflags: '+faststart',
         },
+      },
     },
   }.freeze
   VIDEO_STYLES = {
-- 
cgit 


From f0a2a6c875e9294f0ea1d4c6bc90529e41a2dc37 Mon Sep 17 00:00:00 2001
From: beatrix <beatrix.bitrot@gmail.com>
Date: Mon, 9 Oct 2017 09:56:17 -0400
Subject: try to tighten up local only toot stuff, like... properly (#163)

* try to tighten up local only toot stuff, like... properly

* try to un-break tests
---
 app/controllers/stream_entries_controller.rb | 2 +-
 app/models/status.rb                         | 5 +++++
 app/models/stream_entry.rb                   | 2 +-
 app/policies/status_policy.rb                | 6 ++++++
 4 files changed, 13 insertions(+), 2 deletions(-)

(limited to 'app/models')

diff --git a/app/controllers/stream_entries_controller.rb b/app/controllers/stream_entries_controller.rb
index cc579dbc8..5f61e2182 100644
--- a/app/controllers/stream_entries_controller.rb
+++ b/app/controllers/stream_entries_controller.rb
@@ -48,7 +48,7 @@ class StreamEntriesController < ApplicationController
     @type         = @stream_entry.activity_type.downcase
 
     raise ActiveRecord::RecordNotFound if @stream_entry.activity.nil?
-    authorize @stream_entry.activity, :show? if @stream_entry.hidden?
+    authorize @stream_entry.activity, :show? if @stream_entry.hidden? || @stream_entry.local_only?
   rescue Mastodon::NotPermittedError
     # Reraise in order to get a 404
     raise ActiveRecord::RecordNotFound
diff --git a/app/models/status.rb b/app/models/status.rb
index ea4c097bf..e1697b8af 100644
--- a/app/models/status.rb
+++ b/app/models/status.rb
@@ -257,6 +257,11 @@ class Status < ApplicationRecord
     end
   end
 
+  def local_only?
+    # match both with and without U+FE0F (the emoji variation selector)
+    /👁\ufe0f?\z/.match?(content)
+  end
+
   private
 
   def store_uri
diff --git a/app/models/stream_entry.rb b/app/models/stream_entry.rb
index 44aac39b3..cff232916 100644
--- a/app/models/stream_entry.rb
+++ b/app/models/stream_entry.rb
@@ -28,7 +28,7 @@ class StreamEntry < ApplicationRecord
   scope :recent, -> { reorder(id: :desc) }
   scope :with_includes, -> { includes(:account, status: STATUS_INCLUDES) }
 
-  delegate :target, :title, :content, :thread,
+  delegate :target, :title, :content, :thread, :local_only?,
            to: :status,
            allow_nil: true
 
diff --git a/app/policies/status_policy.rb b/app/policies/status_policy.rb
index 2ded61850..f4a5e7c6c 100644
--- a/app/policies/status_policy.rb
+++ b/app/policies/status_policy.rb
@@ -9,6 +9,8 @@ class StatusPolicy
   end
 
   def show?
+    return false if local_only? && account.nil?
+
     if direct?
       owned? || status.mentions.where(account: account).exists?
     elsif private?
@@ -45,4 +47,8 @@ class StatusPolicy
   def private?
     status.private_visibility?
   end
+  
+  def local_only?
+    status.local_only?
+  end
 end
-- 
cgit 


From 9093e2de7a133470eec1049a13465f81928d0119 Mon Sep 17 00:00:00 2001
From: David Yip <yipdw@member.fsf.org>
Date: Mon, 9 Oct 2017 17:28:28 -0500
Subject: Add KeywordMute model.

Gist of the proposed keyword mute implementation:

Keyword mutes are represented server-side as one keyword per record.
For each account, there exists a keyword regex that is generated as one
big alternation of all keywords.  This regex is cached (in Redis, I
guess) so we can quickly get it when filtering in FeedManager.
---
 app/models/keyword_mute.rb                        | 13 +++++++++++++
 db/migrate/20171009222537_create_keyword_mutes.rb | 11 +++++++++++
 db/schema.rb                                      |  9 +++++++++
 spec/fabricators/keyword_mute_fabricator.rb       |  2 ++
 spec/models/keyword_mute_spec.rb                  |  5 +++++
 5 files changed, 40 insertions(+)
 create mode 100644 app/models/keyword_mute.rb
 create mode 100644 db/migrate/20171009222537_create_keyword_mutes.rb
 create mode 100644 spec/fabricators/keyword_mute_fabricator.rb
 create mode 100644 spec/models/keyword_mute_spec.rb

(limited to 'app/models')

diff --git a/app/models/keyword_mute.rb b/app/models/keyword_mute.rb
new file mode 100644
index 000000000..91816eed9
--- /dev/null
+++ b/app/models/keyword_mute.rb
@@ -0,0 +1,13 @@
+# == Schema Information
+#
+# Table name: keyword_mutes
+#
+#  id         :integer          not null, primary key
+#  account_id :integer          not null
+#  keyword    :string           not null
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
+class KeywordMute < ApplicationRecord
+end
diff --git a/db/migrate/20171009222537_create_keyword_mutes.rb b/db/migrate/20171009222537_create_keyword_mutes.rb
new file mode 100644
index 000000000..ee690e799
--- /dev/null
+++ b/db/migrate/20171009222537_create_keyword_mutes.rb
@@ -0,0 +1,11 @@
+class CreateKeywordMutes < ActiveRecord::Migration[5.1]
+  def change
+    create_table :keyword_mutes do |t|
+      t.references :account, null: false
+      t.string :keyword, null: false
+      t.timestamps
+    end
+
+    add_foreign_key :keyword_mutes, :accounts, on_delete: :cascade
+  end
+end
diff --git a/db/schema.rb b/db/schema.rb
index 128f51ee7..420bb0d2e 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -167,6 +167,14 @@ ActiveRecord::Schema.define(version: 20171010025614) do
     t.bigint "account_id", null: false
   end
 
+  create_table "keyword_mutes", force: :cascade do |t|
+    t.bigint "account_id", null: false
+    t.string "keyword", null: false
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.index ["account_id"], name: "index_keyword_mutes_on_account_id"
+  end
+
   create_table "media_attachments", force: :cascade do |t|
     t.bigint "status_id"
     t.string "file_file_name"
@@ -473,6 +481,7 @@ ActiveRecord::Schema.define(version: 20171010025614) do
   add_foreign_key "follows", "accounts", column: "target_account_id", name: "fk_745ca29eac", on_delete: :cascade
   add_foreign_key "follows", "accounts", name: "fk_32ed1b5560", on_delete: :cascade
   add_foreign_key "imports", "accounts", name: "fk_6db1b6e408", on_delete: :cascade
+  add_foreign_key "keyword_mutes", "accounts", on_delete: :cascade
   add_foreign_key "media_attachments", "accounts", name: "fk_96dd81e81b", on_delete: :nullify
   add_foreign_key "media_attachments", "statuses", on_delete: :nullify
   add_foreign_key "mentions", "accounts", name: "fk_970d43f9d1", on_delete: :cascade
diff --git a/spec/fabricators/keyword_mute_fabricator.rb b/spec/fabricators/keyword_mute_fabricator.rb
new file mode 100644
index 000000000..82cf845c8
--- /dev/null
+++ b/spec/fabricators/keyword_mute_fabricator.rb
@@ -0,0 +1,2 @@
+Fabricator(:keyword_mute) do
+end
diff --git a/spec/models/keyword_mute_spec.rb b/spec/models/keyword_mute_spec.rb
new file mode 100644
index 000000000..cd0881565
--- /dev/null
+++ b/spec/models/keyword_mute_spec.rb
@@ -0,0 +1,5 @@
+require 'rails_helper'
+
+RSpec.describe KeywordMute, type: :model do
+  pending "add some examples to (or delete) #{__FILE__}"
+end
-- 
cgit 


From 4745d6eeca3a422f41775ee5f31989fc036da7d6 Mon Sep 17 00:00:00 2001
From: David Yip <yipdw@member.fsf.org>
Date: Sat, 14 Oct 2017 02:28:20 -0500
Subject: Spec out KeywordMute interface.  #164.

---
 app/lib/feed_manager.rb          |  2 ++
 app/models/keyword_mute.rb       |  2 ++
 spec/models/keyword_mute_spec.rb | 18 +++++++++++++++++-
 3 files changed, 21 insertions(+), 1 deletion(-)

(limited to 'app/models')

diff --git a/app/lib/feed_manager.rb b/app/lib/feed_manager.rb
index ca15745cb..baaa09e86 100644
--- a/app/lib/feed_manager.rb
+++ b/app/lib/feed_manager.rb
@@ -138,6 +138,8 @@ class FeedManager
   end
 
   def filter_from_home?(status, receiver_id)
+    return true if KeywordMute.where(account_id: receiver_id).matches?(status.text)
+
     return false if receiver_id == status.account_id
     return true  if status.reply? && (status.in_reply_to_id.nil? || status.in_reply_to_account_id.nil?)
 
diff --git a/app/models/keyword_mute.rb b/app/models/keyword_mute.rb
index 91816eed9..d397a1f41 100644
--- a/app/models/keyword_mute.rb
+++ b/app/models/keyword_mute.rb
@@ -10,4 +10,6 @@
 #
 
 class KeywordMute < ApplicationRecord
+  def self.matches?(text)
+  end
 end
diff --git a/spec/models/keyword_mute_spec.rb b/spec/models/keyword_mute_spec.rb
index cd0881565..cb6e554e4 100644
--- a/spec/models/keyword_mute_spec.rb
+++ b/spec/models/keyword_mute_spec.rb
@@ -1,5 +1,21 @@
 require 'rails_helper'
 
 RSpec.describe KeywordMute, type: :model do
-  pending "add some examples to (or delete) #{__FILE__}"
+  describe '.matches?' do
+    let(:alice)  { Fabricate(:account, username: 'alice').tap(&:save!) }
+    let(:status) { Fabricate(:status, account: alice).tap(&:save!) }
+    let(:keyword_mute) { Fabricate(:keyword_mute, account: alice, keyword: 'take').tap(&:save!) }
+
+    it 'returns true if any keyword in the set matches the status text' do
+      status.update_attribute(:text, 'This is a hot take')
+
+      expect(KeywordMute.where(account: alice).matches?(status.text)).to be_truthy
+    end
+
+    it 'returns false if no keyword in the set matches the status text'
+
+    describe 'matching' do
+      it 'is case-insensitive'
+    end
+  end
 end
-- 
cgit 


From 603cf02b703a2df2ae6690077a3e21a5ce64b548 Mon Sep 17 00:00:00 2001
From: David Yip <yipdw@member.fsf.org>
Date: Sat, 14 Oct 2017 20:36:53 -0500
Subject: Rework KeywordMute interface to use a matcher object; spec out
 matcher.  #164.

A matcher object that builds a match from KeywordMute data and runs it
over text is, in my view, one of the easier ways to write examples for
this sort of thing.
---
 app/lib/feed_manager.rb          |  2 +-
 app/models/keyword_mute.rb       | 31 +++++++++++++++++-
 spec/models/keyword_mute_spec.rb | 70 ++++++++++++++++++++++++++++++++++------
 3 files changed, 91 insertions(+), 12 deletions(-)

(limited to 'app/models')

diff --git a/app/lib/feed_manager.rb b/app/lib/feed_manager.rb
index baaa09e86..516bd81af 100644
--- a/app/lib/feed_manager.rb
+++ b/app/lib/feed_manager.rb
@@ -138,7 +138,7 @@ class FeedManager
   end
 
   def filter_from_home?(status, receiver_id)
-    return true if KeywordMute.where(account_id: receiver_id).matches?(status.text)
+    return true if KeywordMute.matcher_for(receiver_id) =~ status.text
 
     return false if receiver_id == status.account_id
     return true  if status.reply? && (status.in_reply_to_id.nil? || status.in_reply_to_account_id.nil?)
diff --git a/app/models/keyword_mute.rb b/app/models/keyword_mute.rb
index d397a1f41..d80fcaa60 100644
--- a/app/models/keyword_mute.rb
+++ b/app/models/keyword_mute.rb
@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # == Schema Information
 #
 # Table name: keyword_mutes
@@ -10,6 +11,34 @@
 #
 
 class KeywordMute < ApplicationRecord
-  def self.matches?(text)
+  belongs_to :account, required: true
+
+  validates_presence_of :keyword
+
+  def self.matcher_for(account)
+    Rails.cache.fetch("keyword_mutes:matcher:#{account}") { Matcher.new(account) }
+  end
+
+  class Matcher
+    attr_reader :regex
+
+    def initialize(account)
+      re = String.new.tap do |str|
+        scoped = KeywordMute.where(account: account)
+        keywords = scoped.select(:id, :keyword)
+        count = scoped.count
+
+        keywords.find_each.with_index do |kw, index|
+          str << Regexp.escape(kw.keyword.strip)
+          str << '|' if index < count - 1
+        end
+      end
+
+      @regex = /\b(?:#{re})\b/i unless re.empty?
+    end
+
+    def =~(str)
+      @regex ? @regex =~ str : false
+    end
   end
 end
diff --git a/spec/models/keyword_mute_spec.rb b/spec/models/keyword_mute_spec.rb
index cb6e554e4..211a9b4c6 100644
--- a/spec/models/keyword_mute_spec.rb
+++ b/spec/models/keyword_mute_spec.rb
@@ -1,21 +1,71 @@
 require 'rails_helper'
 
 RSpec.describe KeywordMute, type: :model do
-  describe '.matches?' do
-    let(:alice)  { Fabricate(:account, username: 'alice').tap(&:save!) }
-    let(:status) { Fabricate(:status, account: alice).tap(&:save!) }
-    let(:keyword_mute) { Fabricate(:keyword_mute, account: alice, keyword: 'take').tap(&:save!) }
+  let(:alice) { Fabricate(:account, username: 'alice').tap(&:save!) }
+  let(:bob) { Fabricate(:account, username: 'bob').tap(&:save!) }
 
-    it 'returns true if any keyword in the set matches the status text' do
-      status.update_attribute(:text, 'This is a hot take')
+  describe '.matcher_for' do
+    let(:matcher) { KeywordMute.matcher_for(alice) }
 
-      expect(KeywordMute.where(account: alice).matches?(status.text)).to be_truthy
+    describe 'with no KeywordMutes for an account' do
+      before do
+        KeywordMute.delete_all
+      end
+
+      it 'does not match' do
+        expect(matcher =~ 'This is a hot take').to be_falsy
+      end
     end
 
-    it 'returns false if no keyword in the set matches the status text'
+    describe 'with KeywordMutes for an account' do
+      it 'does not match keywords set by a different account' do
+        KeywordMute.create!(account: bob, keyword: 'take')
+
+        expect(matcher =~ 'This is a hot take').to be_falsy
+      end
+
+      it 'does not match if no keywords match the status text' do
+        KeywordMute.create!(account: alice, keyword: 'cold')
+
+        expect(matcher =~ 'This is a hot take').to be_falsy
+      end
+
+      it 'does not match substrings matching keywords' do
+        KeywordMute.create!(account: alice, keyword: 'take')
+
+        expect(matcher =~ 'This is a shiitake mushroom').to be_falsy
+      end
+
+      it 'matches keywords at the beginning of the text' do
+        KeywordMute.create!(account: alice, keyword: 'take')
+
+        expect(matcher =~ 'Take this').to be_truthy
+      end
+
+      it 'matches keywords at the beginning of the text' do
+        KeywordMute.create!(account: alice, keyword: 'take')
+
+        expect(matcher =~ 'This is a hot take').to be_truthy
+      end
+
+      it 'matches if at least one keyword case-insensitively matches the text' do
+        KeywordMute.create!(account: alice, keyword: 'hot')
+
+        expect(matcher =~ 'This is a hot take').to be_truthy
+      end
+
+      it 'uses case-folding rules appropriate for more than just English' do
+        KeywordMute.create!(account: alice, keyword: 'großeltern')
+
+        expect(matcher =~ 'besuch der grosseltern').to be_truthy
+      end
+
+      it 'matches keywords that are composed of multiple words' do
+        KeywordMute.create!(account: alice, keyword: 'a shiitake')
 
-    describe 'matching' do
-      it 'is case-insensitive'
+        expect(matcher =~ 'This is a shiitake').to be_truthy
+        expect(matcher =~ 'This is shiitake').to_not be_truthy
+      end
     end
   end
 end
-- 
cgit 


From a4851100fd3f20fdc01a3ebf7942fab6d5d03ebf Mon Sep 17 00:00:00 2001
From: David Yip <yipdw@member.fsf.org>
Date: Sat, 14 Oct 2017 20:45:14 -0500
Subject: Make use of the regex attr_reader.  #164.

It would also have been valid to get rid of the attr_reader, but I like
being able to reach inside KeywordMute::Matcher without resorting to
instance_variable_get tomfoolery.
---
 app/models/keyword_mute.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'app/models')

diff --git a/app/models/keyword_mute.rb b/app/models/keyword_mute.rb
index d80fcaa60..e1a8c3712 100644
--- a/app/models/keyword_mute.rb
+++ b/app/models/keyword_mute.rb
@@ -38,7 +38,7 @@ class KeywordMute < ApplicationRecord
     end
 
     def =~(str)
-      @regex ? @regex =~ str : false
+      regex ? regex =~ str : false
     end
   end
 end
-- 
cgit 


From 693c66dfde891a5d540dc4cdc0c712495c31100c Mon Sep 17 00:00:00 2001
From: David Yip <yipdw@member.fsf.org>
Date: Sun, 15 Oct 2017 02:32:03 -0500
Subject: Use more idiomatic string concatentation.  #164.

The intent of the previous concatenation was to minimize object
allocations, which can end up being a slow killer.  However, it turns
out that under MRI 2.4.x, the shove-strings-in-an-array-and-join method
is not only arguably more common but (in this particular case) actually
allocates *fewer* objects than the string concatenation.

Or, at least, that's what I gather by running this:

    words = %w(palmettoes nudged hibernation bullish stockade's tightened Hades
    Dixie's formalize superego's commissaries Zappa's viceroy's apothecaries
    tablespoonful's barons Chennai tollgate ticked expands)

    a = Account.first

    KeywordMute.transaction do
      words.each { |w| KeywordMute.create!(keyword: w, account: a) }

      GC.start

      s1 = GC.stat

      re = String.new.tap do |str|
        scoped = KeywordMute.where(account: a)
        keywords = scoped.select(:id, :keyword)
        count = scoped.count

        keywords.find_each.with_index do |kw, index|
          str << Regexp.escape(kw.keyword.strip)
          str << '|' if index < count - 1
        end
      end

      s2 = GC.stat

      puts s1.inspect, s2.inspect

      raise ActiveRecord::Rollback
    end

vs this:

    words = %w( palmettoes nudged hibernation bullish stockade's tightened Hades Dixie's
    formalize superego's commissaries Zappa's viceroy's apothecaries tablespoonful's
    barons Chennai tollgate ticked expands
    )

    a = Account.first

    KeywordMute.transaction do
      words.each { |w| KeywordMute.create!(keyword: w, account: a) }

      GC.start

      s1 = GC.stat

      re = [].tap do |arr|
        KeywordMute.where(account: a).select(:keyword, :id).find_each do |m|
          arr << Regexp.escape(m.keyword.strip)
        end
      end.join('|')

      s2 = GC.stat

      puts s1.inspect, s2.inspect

      raise ActiveRecord::Rollback
    end

Using rails r, here is a comparison of the total_allocated_objects and
malloc_increase_bytes GC stat data:

                 total_allocated_objects        malloc_increase_bytes
string concat    3200241 -> 3201428 (+1187)     1176 -> 45216 (44040)
array join       3200380 -> 3201299 (+919)      1176 -> 36448 (35272)
---
 app/models/keyword_mute.rb | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

(limited to 'app/models')

diff --git a/app/models/keyword_mute.rb b/app/models/keyword_mute.rb
index e1a8c3712..f94e0f795 100644
--- a/app/models/keyword_mute.rb
+++ b/app/models/keyword_mute.rb
@@ -23,16 +23,11 @@ class KeywordMute < ApplicationRecord
     attr_reader :regex
 
     def initialize(account)
-      re = String.new.tap do |str|
-        scoped = KeywordMute.where(account: account)
-        keywords = scoped.select(:id, :keyword)
-        count = scoped.count
-
-        keywords.find_each.with_index do |kw, index|
-          str << Regexp.escape(kw.keyword.strip)
-          str << '|' if index < count - 1
+      re = [].tap do |arr|
+        KeywordMute.where(account: account).select(:keyword, :id).find_each do |m|
+          arr << Regexp.escape(m.keyword.strip)
         end
-      end
+      end.join('|')
 
       @regex = /\b(?:#{re})\b/i unless re.empty?
     end
-- 
cgit 


From b4b657eb1daebd1472384ff8ea1c1b9c4b313c5c Mon Sep 17 00:00:00 2001
From: David Yip <yipdw@member.fsf.org>
Date: Sun, 15 Oct 2017 02:52:53 -0500
Subject: Invalidate cached matcher objects on KeywordMute commit.  #164.

---
 app/models/keyword_mute.rb | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

(limited to 'app/models')

diff --git a/app/models/keyword_mute.rb b/app/models/keyword_mute.rb
index f94e0f795..8b54ad696 100644
--- a/app/models/keyword_mute.rb
+++ b/app/models/keyword_mute.rb
@@ -15,16 +15,24 @@ class KeywordMute < ApplicationRecord
 
   validates_presence_of :keyword
 
-  def self.matcher_for(account)
-    Rails.cache.fetch("keyword_mutes:matcher:#{account}") { Matcher.new(account) }
+  after_commit :invalidate_cached_matcher
+
+  def self.matcher_for(account_id)
+    Rails.cache.fetch("keyword_mutes:matcher:#{account_id}") { Matcher.new(account_id) }
+  end
+
+  private
+
+  def invalidate_cached_matcher
+    Rails.cache.delete("keyword_mutes:matcher:#{account_id}")
   end
 
   class Matcher
     attr_reader :regex
 
-    def initialize(account)
+    def initialize(account_id)
       re = [].tap do |arr|
-        KeywordMute.where(account: account).select(:keyword, :id).find_each do |m|
+        KeywordMute.where(account_id: account_id).select(:keyword, :id).find_each do |m|
           arr << Regexp.escape(m.keyword.strip)
         end
       end.join('|')
-- 
cgit 


From 4a64181461cb02599da98166da4b527adbb705ad Mon Sep 17 00:00:00 2001
From: David Yip <yipdw@member.fsf.org>
Date: Sun, 15 Oct 2017 19:49:22 -0500
Subject: Allow keywords to match either substrings or whole words.

Word-boundary matching only works as intended in English and languages
that use similar word-breaking characters; it doesn't work so well in
(say) Japanese, Chinese, or Thai.  It's unacceptable to have a feature
that doesn't work as intended for some languages.  (Moreso especially
considering that it's likely that the largest contingent on the Mastodon
bit of the fediverse speaks Japanese.)

There are rules specified in Unicode TR29[1] for word-breaking across
all languages supported by Unicode, but the rules deliberately do not
cover all cases.  In fact, TR29 states

    For example, reliable detection of word boundaries in languages such
    as Thai, Lao, Chinese, or Japanese requires the use of dictionary
    lookup, analogous to English hyphenation.

So we aren't going to be able to make word detection work with regexes
within Mastodon (or glitchsoc).  However, for a first pass (even if it's
kind of punting) we can allow the user to choose whether they want word
or substring detection and warn about the limitations of this
implementation in, say, docs.

[1]: https://unicode.org/reports/tr29/
     https://web.archive.org/web/20171001005125/https://unicode.org/reports/tr29/
---
 app/models/keyword_mute.rb                        |  8 +++++---
 db/migrate/20171009222537_create_keyword_mutes.rb |  1 +
 db/schema.rb                                      |  1 +
 spec/models/keyword_mute_spec.rb                  | 12 +++++++++---
 4 files changed, 16 insertions(+), 6 deletions(-)

(limited to 'app/models')

diff --git a/app/models/keyword_mute.rb b/app/models/keyword_mute.rb
index 8b54ad696..b0229923d 100644
--- a/app/models/keyword_mute.rb
+++ b/app/models/keyword_mute.rb
@@ -6,6 +6,7 @@
 #  id         :integer          not null, primary key
 #  account_id :integer          not null
 #  keyword    :string           not null
+#  whole_word :boolean          default(TRUE), not null
 #  created_at :datetime         not null
 #  updated_at :datetime         not null
 #
@@ -32,12 +33,13 @@ class KeywordMute < ApplicationRecord
 
     def initialize(account_id)
       re = [].tap do |arr|
-        KeywordMute.where(account_id: account_id).select(:keyword, :id).find_each do |m|
-          arr << Regexp.escape(m.keyword.strip)
+        KeywordMute.where(account_id: account_id).select(:keyword, :id, :whole_word).find_each do |m|
+          boundary = m.whole_word ? '\b' : ''
+          arr << "#{boundary}#{Regexp.escape(m.keyword.strip)}#{boundary}"
         end
       end.join('|')
 
-      @regex = /\b(?:#{re})\b/i unless re.empty?
+      @regex = /#{re}/i unless re.empty?
     end
 
     def =~(str)
diff --git a/db/migrate/20171009222537_create_keyword_mutes.rb b/db/migrate/20171009222537_create_keyword_mutes.rb
index ee690e799..ec0c756fb 100644
--- a/db/migrate/20171009222537_create_keyword_mutes.rb
+++ b/db/migrate/20171009222537_create_keyword_mutes.rb
@@ -3,6 +3,7 @@ class CreateKeywordMutes < ActiveRecord::Migration[5.1]
     create_table :keyword_mutes do |t|
       t.references :account, null: false
       t.string :keyword, null: false
+      t.boolean :whole_word, null: false, default: true
       t.timestamps
     end
 
diff --git a/db/schema.rb b/db/schema.rb
index 420bb0d2e..c0704b13e 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -170,6 +170,7 @@ ActiveRecord::Schema.define(version: 20171010025614) do
   create_table "keyword_mutes", force: :cascade do |t|
     t.bigint "account_id", null: false
     t.string "keyword", null: false
+    t.boolean "whole_word", default: true, null: false
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
     t.index ["account_id"], name: "index_keyword_mutes_on_account_id"
diff --git a/spec/models/keyword_mute_spec.rb b/spec/models/keyword_mute_spec.rb
index de5d32bb4..c74505188 100644
--- a/spec/models/keyword_mute_spec.rb
+++ b/spec/models/keyword_mute_spec.rb
@@ -30,10 +30,16 @@ RSpec.describe KeywordMute, type: :model do
         expect(matcher =~ 'This is a hot take').to be_falsy
       end
 
-      it 'does not match substrings matching keywords' do
-        KeywordMute.create!(account: alice, keyword: 'take')
+      it 'considers word boundaries when matching' do
+        KeywordMute.create!(account: alice, keyword: 'bob', whole_word: true)
+
+        expect(matcher =~ 'bobcats').to be_falsy
+      end
+
+      it 'matches substrings if whole_word is false' do
+        KeywordMute.create!(account: alice, keyword: 'take', whole_word: false)
 
-        expect(matcher =~ 'This is a shiitake mushroom').to be_falsy
+        expect(matcher =~ 'This is a shiitake mushroom').to be_truthy
       end
 
       it 'matches keywords at the beginning of the text' do
-- 
cgit 


From 670e6a33f8eeca628707dc020e02ce32502d74a4 Mon Sep 17 00:00:00 2001
From: David Yip <yipdw@member.fsf.org>
Date: Sat, 21 Oct 2017 14:47:17 -0500
Subject: Move KeywordMute into Glitch namespace.

There are two motivations for this:

1. It looks like we're going to add other features that require
   server-side storage (e.g. user notes).

2. Namespacing glitchsoc modifications is a good idea anyway: even if we
   do not end up doing (1), if upstream introduces a keyword-mute feature
   that also uses a "KeywordMute" model, we can avoid some merge
   conflicts this way and work on the more interesting task of
   choosing which implementation to use.
---
 .../settings/keyword_mutes_controller.rb           |  2 +-
 app/lib/feed_manager.rb                            |  2 +-
 app/models/glitch.rb                               |  7 ++
 app/models/glitch/keyword_mute.rb                  | 49 +++++++++++++
 app/models/keyword_mute.rb                         | 49 -------------
 ...900_move_keyword_mutes_into_glitch_namespace.rb |  7 ++
 db/schema.rb                                       | 22 +++---
 spec/fabricators/glitch_keyword_mute_fabricator.rb |  2 +
 spec/fabricators/keyword_mute_fabricator.rb        |  2 -
 spec/models/glitch/keyword_mute_spec.rb            | 83 ++++++++++++++++++++++
 spec/models/keyword_mute_spec.rb                   | 83 ----------------------
 11 files changed, 161 insertions(+), 147 deletions(-)
 create mode 100644 app/models/glitch.rb
 create mode 100644 app/models/glitch/keyword_mute.rb
 delete mode 100644 app/models/keyword_mute.rb
 create mode 100644 db/migrate/20171021191900_move_keyword_mutes_into_glitch_namespace.rb
 create mode 100644 spec/fabricators/glitch_keyword_mute_fabricator.rb
 delete mode 100644 spec/fabricators/keyword_mute_fabricator.rb
 create mode 100644 spec/models/glitch/keyword_mute_spec.rb
 delete mode 100644 spec/models/keyword_mute_spec.rb

(limited to 'app/models')

diff --git a/app/controllers/settings/keyword_mutes_controller.rb b/app/controllers/settings/keyword_mutes_controller.rb
index d9f99af09..6ae05108d 100644
--- a/app/controllers/settings/keyword_mutes_controller.rb
+++ b/app/controllers/settings/keyword_mutes_controller.rb
@@ -55,7 +55,7 @@ class Settings::KeywordMutesController < ApplicationController
   end
 
   def keyword_mutes_for_account
-    KeywordMute.where(account: @account)
+    Glitch::KeywordMute.where(account: @account)
   end
 
   def load_keyword_mute
diff --git a/app/lib/feed_manager.rb b/app/lib/feed_manager.rb
index 516bd81af..1123f88bb 100644
--- a/app/lib/feed_manager.rb
+++ b/app/lib/feed_manager.rb
@@ -138,7 +138,7 @@ class FeedManager
   end
 
   def filter_from_home?(status, receiver_id)
-    return true if KeywordMute.matcher_for(receiver_id) =~ status.text
+    return true if Glitch::KeywordMute.matcher_for(receiver_id) =~ status.text
 
     return false if receiver_id == status.account_id
     return true  if status.reply? && (status.in_reply_to_id.nil? || status.in_reply_to_account_id.nil?)
diff --git a/app/models/glitch.rb b/app/models/glitch.rb
new file mode 100644
index 000000000..0e497babc
--- /dev/null
+++ b/app/models/glitch.rb
@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Glitch
+  def self.table_name_prefix
+    'glitch_'
+  end
+end
diff --git a/app/models/glitch/keyword_mute.rb b/app/models/glitch/keyword_mute.rb
new file mode 100644
index 000000000..3b0b47f52
--- /dev/null
+++ b/app/models/glitch/keyword_mute.rb
@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+# == Schema Information
+#
+# Table name: glitch_keyword_mutes
+#
+#  id         :integer          not null, primary key
+#  account_id :integer          not null
+#  keyword    :string           not null
+#  whole_word :boolean          default(TRUE), not null
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
+class Glitch::KeywordMute < ApplicationRecord
+  belongs_to :account, required: true
+
+  validates_presence_of :keyword
+
+  after_commit :invalidate_cached_matcher
+
+  def self.matcher_for(account_id)
+    Rails.cache.fetch("keyword_mutes:matcher:#{account_id}") { Matcher.new(account_id) }
+  end
+
+  private
+
+  def invalidate_cached_matcher
+    Rails.cache.delete("keyword_mutes:matcher:#{account_id}")
+  end
+
+  class Matcher
+    attr_reader :regex
+
+    def initialize(account_id)
+      re = [].tap do |arr|
+        Glitch::KeywordMute.where(account_id: account_id).select(:keyword, :id, :whole_word).find_each do |m|
+          boundary = m.whole_word ? '\b' : ''
+          arr << "#{boundary}#{Regexp.escape(m.keyword.strip)}#{boundary}"
+        end
+      end.join('|')
+
+      @regex = /#{re}/i unless re.empty?
+    end
+
+    def =~(str)
+      regex ? regex =~ str : false
+    end
+  end
+end
diff --git a/app/models/keyword_mute.rb b/app/models/keyword_mute.rb
deleted file mode 100644
index b0229923d..000000000
--- a/app/models/keyword_mute.rb
+++ /dev/null
@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-# == Schema Information
-#
-# Table name: keyword_mutes
-#
-#  id         :integer          not null, primary key
-#  account_id :integer          not null
-#  keyword    :string           not null
-#  whole_word :boolean          default(TRUE), not null
-#  created_at :datetime         not null
-#  updated_at :datetime         not null
-#
-
-class KeywordMute < ApplicationRecord
-  belongs_to :account, required: true
-
-  validates_presence_of :keyword
-
-  after_commit :invalidate_cached_matcher
-
-  def self.matcher_for(account_id)
-    Rails.cache.fetch("keyword_mutes:matcher:#{account_id}") { Matcher.new(account_id) }
-  end
-
-  private
-
-  def invalidate_cached_matcher
-    Rails.cache.delete("keyword_mutes:matcher:#{account_id}")
-  end
-
-  class Matcher
-    attr_reader :regex
-
-    def initialize(account_id)
-      re = [].tap do |arr|
-        KeywordMute.where(account_id: account_id).select(:keyword, :id, :whole_word).find_each do |m|
-          boundary = m.whole_word ? '\b' : ''
-          arr << "#{boundary}#{Regexp.escape(m.keyword.strip)}#{boundary}"
-        end
-      end.join('|')
-
-      @regex = /#{re}/i unless re.empty?
-    end
-
-    def =~(str)
-      regex ? regex =~ str : false
-    end
-  end
-end
diff --git a/db/migrate/20171021191900_move_keyword_mutes_into_glitch_namespace.rb b/db/migrate/20171021191900_move_keyword_mutes_into_glitch_namespace.rb
new file mode 100644
index 000000000..269bb49d6
--- /dev/null
+++ b/db/migrate/20171021191900_move_keyword_mutes_into_glitch_namespace.rb
@@ -0,0 +1,7 @@
+class MoveKeywordMutesIntoGlitchNamespace < ActiveRecord::Migration[5.1]
+  def change
+    safety_assured do
+      rename_table :keyword_mutes, :glitch_keyword_mutes
+    end
+  end
+end
diff --git a/db/schema.rb b/db/schema.rb
index c0704b13e..c09876c4d 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20171010025614) do
+ActiveRecord::Schema.define(version: 20171021191900) do
 
   # These are extensions that must be enabled in order to support this database
   enable_extension "plpgsql"
@@ -155,6 +155,15 @@ ActiveRecord::Schema.define(version: 20171010025614) do
     t.index ["account_id", "target_account_id"], name: "index_follows_on_account_id_and_target_account_id", unique: true
   end
 
+  create_table "glitch_keyword_mutes", force: :cascade do |t|
+    t.bigint "account_id", null: false
+    t.string "keyword", null: false
+    t.boolean "whole_word", default: true, null: false
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.index ["account_id"], name: "index_glitch_keyword_mutes_on_account_id"
+  end
+
   create_table "imports", force: :cascade do |t|
     t.integer "type", null: false
     t.boolean "approved", default: false, null: false
@@ -167,15 +176,6 @@ ActiveRecord::Schema.define(version: 20171010025614) do
     t.bigint "account_id", null: false
   end
 
-  create_table "keyword_mutes", force: :cascade do |t|
-    t.bigint "account_id", null: false
-    t.string "keyword", null: false
-    t.boolean "whole_word", default: true, null: false
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.index ["account_id"], name: "index_keyword_mutes_on_account_id"
-  end
-
   create_table "media_attachments", force: :cascade do |t|
     t.bigint "status_id"
     t.string "file_file_name"
@@ -481,8 +481,8 @@ ActiveRecord::Schema.define(version: 20171010025614) do
   add_foreign_key "follow_requests", "accounts", name: "fk_76d644b0e7", on_delete: :cascade
   add_foreign_key "follows", "accounts", column: "target_account_id", name: "fk_745ca29eac", on_delete: :cascade
   add_foreign_key "follows", "accounts", name: "fk_32ed1b5560", on_delete: :cascade
+  add_foreign_key "glitch_keyword_mutes", "accounts", on_delete: :cascade
   add_foreign_key "imports", "accounts", name: "fk_6db1b6e408", on_delete: :cascade
-  add_foreign_key "keyword_mutes", "accounts", on_delete: :cascade
   add_foreign_key "media_attachments", "accounts", name: "fk_96dd81e81b", on_delete: :nullify
   add_foreign_key "media_attachments", "statuses", on_delete: :nullify
   add_foreign_key "mentions", "accounts", name: "fk_970d43f9d1", on_delete: :cascade
diff --git a/spec/fabricators/glitch_keyword_mute_fabricator.rb b/spec/fabricators/glitch_keyword_mute_fabricator.rb
new file mode 100644
index 000000000..8601ed6d7
--- /dev/null
+++ b/spec/fabricators/glitch_keyword_mute_fabricator.rb
@@ -0,0 +1,2 @@
+Fabricator(:glitch_keyword_mute) do
+end
diff --git a/spec/fabricators/keyword_mute_fabricator.rb b/spec/fabricators/keyword_mute_fabricator.rb
deleted file mode 100644
index 82cf845c8..000000000
--- a/spec/fabricators/keyword_mute_fabricator.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-Fabricator(:keyword_mute) do
-end
diff --git a/spec/models/glitch/keyword_mute_spec.rb b/spec/models/glitch/keyword_mute_spec.rb
new file mode 100644
index 000000000..108cdafec
--- /dev/null
+++ b/spec/models/glitch/keyword_mute_spec.rb
@@ -0,0 +1,83 @@
+require 'rails_helper'
+
+RSpec.describe Glitch::KeywordMute, type: :model do
+  let(:alice) { Fabricate(:account, username: 'alice').tap(&:save!) }
+  let(:bob) { Fabricate(:account, username: 'bob').tap(&:save!) }
+
+  describe '.matcher_for' do
+    let(:matcher) { Glitch::KeywordMute.matcher_for(alice) }
+
+    describe 'with no Glitch::KeywordMutes for an account' do
+      before do
+        Glitch::KeywordMute.delete_all
+      end
+
+      it 'does not match' do
+        expect(matcher =~ 'This is a hot take').to be_falsy
+      end
+    end
+
+    describe 'with Glitch::KeywordMutes for an account' do
+      it 'does not match keywords set by a different account' do
+        Glitch::KeywordMute.create!(account: bob, keyword: 'take')
+
+        expect(matcher =~ 'This is a hot take').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 =~ 'This is a hot take').to be_falsy
+      end
+
+      it 'considers word boundaries when matching' do
+        Glitch::KeywordMute.create!(account: alice, keyword: 'bob', whole_word: true)
+
+        expect(matcher =~ 'bobcats').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 =~ 'This is a shiitake mushroom').to be_truthy
+      end
+
+      it 'matches keywords at the beginning of the text' do
+        Glitch::KeywordMute.create!(account: alice, keyword: 'take')
+
+        expect(matcher =~ 'Take this').to be_truthy
+      end
+
+      it 'matches keywords at the beginning of the text' do
+        Glitch::KeywordMute.create!(account: alice, keyword: 'take')
+
+        expect(matcher =~ 'This is a hot take').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 =~ 'This is a HOT take').to be_truthy
+      end
+
+      it 'matches keywords surrounded by non-alphanumeric ornamentation' do
+        Glitch::KeywordMute.create!(account: alice, keyword: 'hot')
+
+        expect(matcher =~ 'This is a ~*HOT*~ take').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 =~ 'besuch der grosseltern').to be_truthy
+      end
+
+      it 'matches keywords that are composed of multiple words' do
+        Glitch::KeywordMute.create!(account: alice, keyword: 'a shiitake')
+
+        expect(matcher =~ 'This is a shiitake').to be_truthy
+        expect(matcher =~ 'This is shiitake').to_not be_truthy
+      end
+    end
+  end
+end
diff --git a/spec/models/keyword_mute_spec.rb b/spec/models/keyword_mute_spec.rb
deleted file mode 100644
index c74505188..000000000
--- a/spec/models/keyword_mute_spec.rb
+++ /dev/null
@@ -1,83 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe KeywordMute, type: :model do
-  let(:alice) { Fabricate(:account, username: 'alice').tap(&:save!) }
-  let(:bob) { Fabricate(:account, username: 'bob').tap(&:save!) }
-
-  describe '.matcher_for' do
-    let(:matcher) { KeywordMute.matcher_for(alice) }
-
-    describe 'with no KeywordMutes for an account' do
-      before do
-        KeywordMute.delete_all
-      end
-
-      it 'does not match' do
-        expect(matcher =~ 'This is a hot take').to be_falsy
-      end
-    end
-
-    describe 'with KeywordMutes for an account' do
-      it 'does not match keywords set by a different account' do
-        KeywordMute.create!(account: bob, keyword: 'take')
-
-        expect(matcher =~ 'This is a hot take').to be_falsy
-      end
-
-      it 'does not match if no keywords match the status text' do
-        KeywordMute.create!(account: alice, keyword: 'cold')
-
-        expect(matcher =~ 'This is a hot take').to be_falsy
-      end
-
-      it 'considers word boundaries when matching' do
-        KeywordMute.create!(account: alice, keyword: 'bob', whole_word: true)
-
-        expect(matcher =~ 'bobcats').to be_falsy
-      end
-
-      it 'matches substrings if whole_word is false' do
-        KeywordMute.create!(account: alice, keyword: 'take', whole_word: false)
-
-        expect(matcher =~ 'This is a shiitake mushroom').to be_truthy
-      end
-
-      it 'matches keywords at the beginning of the text' do
-        KeywordMute.create!(account: alice, keyword: 'take')
-
-        expect(matcher =~ 'Take this').to be_truthy
-      end
-
-      it 'matches keywords at the beginning of the text' do
-        KeywordMute.create!(account: alice, keyword: 'take')
-
-        expect(matcher =~ 'This is a hot take').to be_truthy
-      end
-
-      it 'matches if at least one keyword case-insensitively matches the text' do
-        KeywordMute.create!(account: alice, keyword: 'hot')
-
-        expect(matcher =~ 'This is a HOT take').to be_truthy
-      end
-
-      it 'matches keywords surrounded by non-alphanumeric ornamentation' do
-        KeywordMute.create!(account: alice, keyword: 'hot')
-
-        expect(matcher =~ 'This is a ~*HOT*~ take').to be_truthy
-      end
-
-      it 'uses case-folding rules appropriate for more than just English' do
-        KeywordMute.create!(account: alice, keyword: 'großeltern')
-
-        expect(matcher =~ 'besuch der grosseltern').to be_truthy
-      end
-
-      it 'matches keywords that are composed of multiple words' do
-        KeywordMute.create!(account: alice, keyword: 'a shiitake')
-
-        expect(matcher =~ 'This is a shiitake').to be_truthy
-        expect(matcher =~ 'This is shiitake').to_not be_truthy
-      end
-    end
-  end
-end
-- 
cgit 


From ad86c86fa8e0d577b1a6c7411367420e6beea4ea Mon Sep 17 00:00:00 2001
From: David Yip <yipdw@member.fsf.org>
Date: Sat, 21 Oct 2017 15:44:47 -0500
Subject: Apply keyword mutes to reblogs.

---
 app/lib/feed_manager.rb                            |  5 ++++-
 app/models/glitch/keyword_mute.rb                  |  4 ++++
 spec/fabricators/glitch_keyword_mute_fabricator.rb |  2 +-
 spec/lib/feed_manager_spec.rb                      | 17 +++++++++++++++++
 4 files changed, 26 insertions(+), 2 deletions(-)

(limited to 'app/models')

diff --git a/app/lib/feed_manager.rb b/app/lib/feed_manager.rb
index 1123f88bb..576188324 100644
--- a/app/lib/feed_manager.rb
+++ b/app/lib/feed_manager.rb
@@ -138,7 +138,9 @@ class FeedManager
   end
 
   def filter_from_home?(status, receiver_id)
-    return true if Glitch::KeywordMute.matcher_for(receiver_id) =~ status.text
+    keyword_mute_matcher = Glitch::KeywordMute.matcher_for(receiver_id)
+
+    return true if keyword_mute_matcher =~ status.text
 
     return false if receiver_id == status.account_id
     return true  if status.reply? && (status.in_reply_to_id.nil? || status.in_reply_to_account_id.nil?)
@@ -161,6 +163,7 @@ class FeedManager
       return should_filter
     elsif status.reblog?                                                                                                 # Filter out a reblog
       should_filter   = Block.where(account_id: status.reblog.account_id, target_account_id: receiver_id).exists?        # or if the author of the reblogged status is blocking me
+      should_filter ||= keyword_mute_matcher.matches?(status.reblog.text)
       should_filter ||= AccountDomainBlock.where(account_id: receiver_id, domain: status.reblog.account.domain).exists?  # or the author's domain is blocked
       return should_filter
     end
diff --git a/app/models/glitch/keyword_mute.rb b/app/models/glitch/keyword_mute.rb
index 3b0b47f52..823e252d3 100644
--- a/app/models/glitch/keyword_mute.rb
+++ b/app/models/glitch/keyword_mute.rb
@@ -45,5 +45,9 @@ class Glitch::KeywordMute < ApplicationRecord
     def =~(str)
       regex ? regex =~ str : false
     end
+
+    def matches?(str)
+      !!(regex =~ str)
+    end
   end
 end
diff --git a/spec/fabricators/glitch_keyword_mute_fabricator.rb b/spec/fabricators/glitch_keyword_mute_fabricator.rb
index 8601ed6d7..20d393320 100644
--- a/spec/fabricators/glitch_keyword_mute_fabricator.rb
+++ b/spec/fabricators/glitch_keyword_mute_fabricator.rb
@@ -1,2 +1,2 @@
-Fabricator(:glitch_keyword_mute) do
+Fabricator('Glitch::KeywordMute') do
 end
diff --git a/spec/lib/feed_manager_spec.rb b/spec/lib/feed_manager_spec.rb
index 1861cc6ed..c9403d616 100644
--- a/spec/lib/feed_manager_spec.rb
+++ b/spec/lib/feed_manager_spec.rb
@@ -119,6 +119,23 @@ RSpec.describe FeedManager do
         reblog = Fabricate(:status, reblog: status, account: jeff)
         expect(FeedManager.instance.filter?(:home, reblog, alice.id)).to be true
       end
+
+      it 'returns true for a status containing a muted keyword' do
+        Fabricate('Glitch::KeywordMute', account: alice, keyword: 'take')
+        alice.follow!(bob)
+        status = Fabricate(:status, text: 'This is a hot take', account: bob)
+
+        expect(FeedManager.instance.filter?(:home, status, alice.id)).to be true
+      end
+
+      it 'returns true for a reblog containing a muted keyword' do
+        Fabricate('Glitch::KeywordMute', account: alice, keyword: 'take')
+        alice.follow!(jeff)
+        status = Fabricate(:status, text: 'This is a hot take', account: bob)
+        reblog = Fabricate(:status, reblog: status, account: jeff)
+
+        expect(FeedManager.instance.filter?(:home, reblog, alice.id)).to be true
+      end
     end
 
     context 'for mentions feed' do
-- 
cgit 


From 4b68e82a19ab2853264515a25af8d39841e43f00 Mon Sep 17 00:00:00 2001
From: David Yip <yipdw@member.fsf.org>
Date: Sun, 22 Oct 2017 00:24:32 -0500
Subject: Don't add \b to whole-word keywords that don't start with word
 characters.

Ditto for ending with \b.

Consider muting the phrase "(hot take)".  I stipulate it is reasonable
to enter this with the default "match whole word" behavior.  Under the
old behavior, this would be encoded as

    \b\(hot\ take\)\b

However, if \b is before the first character in the string and the first
character in the string is not a word character, then the match will
fail.  Ditto for after.  In our example, "(" is not a word character, so
this will not match statuses containing "(hot take)", and that's a very
surprising behavior.

To address this, we only add leading and trailing \b to keywords that
start or end with word characters.
---
 app/models/glitch/keyword_mute.rb       | 36 +++++++++++++++++++++++----------
 spec/models/glitch/keyword_mute_spec.rb | 12 ++++++++---
 2 files changed, 34 insertions(+), 14 deletions(-)

(limited to 'app/models')

diff --git a/app/models/glitch/keyword_mute.rb b/app/models/glitch/keyword_mute.rb
index 823e252d3..20fd89d9b 100644
--- a/app/models/glitch/keyword_mute.rb
+++ b/app/models/glitch/keyword_mute.rb
@@ -19,35 +19,49 @@ class Glitch::KeywordMute < ApplicationRecord
   after_commit :invalidate_cached_matcher
 
   def self.matcher_for(account_id)
-    Rails.cache.fetch("keyword_mutes:matcher:#{account_id}") { Matcher.new(account_id) }
+    Matcher.new(account_id)
   end
 
   private
 
   def invalidate_cached_matcher
-    Rails.cache.delete("keyword_mutes:matcher:#{account_id}")
+    Rails.cache.delete("keyword_mutes:regex:#{account_id}")
   end
 
   class Matcher
+    attr_reader :account_id
     attr_reader :regex
 
     def initialize(account_id)
-      re = [].tap do |arr|
-        Glitch::KeywordMute.where(account_id: account_id).select(:keyword, :id, :whole_word).find_each do |m|
-          boundary = m.whole_word ? '\b' : ''
-          arr << "#{boundary}#{Regexp.escape(m.keyword.strip)}#{boundary}"
+      @account_id = account_id
+      @regex = Rails.cache.fetch("keyword_mutes:regex:#{account_id}") { regex_for_account }
+    end
+
+    def keywords
+      Glitch::KeywordMute.
+        where(account_id: account_id).
+        select(:keyword, :id, :whole_word)
+    end
+
+    def regex_for_account
+      re_text = [].tap do |arr|
+        keywords.find_each do |kw|
+          arr << (kw.whole_word ? boundary_regex_for_keyword(kw.keyword) : Regexp.escape(kw.keyword))
         end
       end.join('|')
 
-      @regex = /#{re}/i unless re.empty?
+      /#{re_text}/i unless re_text.empty?
     end
 
-    def =~(str)
-      regex ? regex =~ str : false
+    def boundary_regex_for_keyword(keyword)
+      sb = keyword =~ /\A[[:word:]]/ ? '\b' : ''
+      eb = keyword =~ /[[:word:]]\Z/ ? '\b' : ''
+
+      "#{sb}#{Regexp.escape(keyword)}#{eb}"
     end
 
-    def matches?(str)
-      !!(regex =~ str)
+    def =~(str)
+      regex ? regex =~ str : false
     end
   end
 end
diff --git a/spec/models/glitch/keyword_mute_spec.rb b/spec/models/glitch/keyword_mute_spec.rb
index 108cdafec..95e59defc 100644
--- a/spec/models/glitch/keyword_mute_spec.rb
+++ b/spec/models/glitch/keyword_mute_spec.rb
@@ -7,7 +7,7 @@ RSpec.describe Glitch::KeywordMute, type: :model do
   describe '.matcher_for' do
     let(:matcher) { Glitch::KeywordMute.matcher_for(alice) }
 
-    describe 'with no Glitch::KeywordMutes for an account' do
+    describe 'with no mutes' do
       before do
         Glitch::KeywordMute.delete_all
       end
@@ -17,7 +17,7 @@ RSpec.describe Glitch::KeywordMute, type: :model do
       end
     end
 
-    describe 'with Glitch::KeywordMutes for an account' do
+    describe 'with mutes' do
       it 'does not match keywords set by a different account' do
         Glitch::KeywordMute.create!(account: bob, keyword: 'take')
 
@@ -63,7 +63,13 @@ RSpec.describe Glitch::KeywordMute, type: :model do
       it 'matches keywords surrounded by non-alphanumeric ornamentation' do
         Glitch::KeywordMute.create!(account: alice, keyword: 'hot')
 
-        expect(matcher =~ 'This is a ~*HOT*~ take').to be_truthy
+        expect(matcher =~ '(hot take)').to be_truthy
+      end
+
+      it 'escapes metacharacters in keywords' do
+        Glitch::KeywordMute.create!(account: alice, keyword: '(hot take)')
+
+        expect(matcher =~ '(hot take)').to be_truthy
       end
 
       it 'uses case-folding rules appropriate for more than just English' do
-- 
cgit 


From af8f06413ee3bab91f1fb89b5828ed9a44e1a6bd Mon Sep 17 00:00:00 2001
From: David Yip <yipdw@member.fsf.org>
Date: Sun, 22 Oct 2017 01:11:17 -0500
Subject: KeywordMute matcher: more closely mimic Regexp#=~ behavior.

Regexp#=~ returns nil if it does not match.  An empty mute set does not
match any status, so KeywordMute::Matcher#=~ ought to return nil also.
---
 app/models/glitch/keyword_mute.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'app/models')

diff --git a/app/models/glitch/keyword_mute.rb b/app/models/glitch/keyword_mute.rb
index 20fd89d9b..a7ab3650e 100644
--- a/app/models/glitch/keyword_mute.rb
+++ b/app/models/glitch/keyword_mute.rb
@@ -61,7 +61,7 @@ class Glitch::KeywordMute < ApplicationRecord
     end
 
     def =~(str)
-      regex ? regex =~ str : false
+      regex ? regex =~ str : nil
     end
   end
 end
-- 
cgit 


From 3db80f75a6d76a7eea576413c5ae9b206d2ab385 Mon Sep 17 00:00:00 2001
From: Matthew Walsh <mattwcstrfan@gmail.com>
Date: Sun, 15 Oct 2017 21:02:39 -0700
Subject: Added a timeline for Direct statuses * Lists all Direct statuses
 you've sent and received * Displayed in Getting Started * Streaming server
 support for direct TL

---
 .../api/v1/timelines/direct_controller.rb          |  60 ++++++++++++
 app/javascript/mastodon/actions/compose.js         |   2 +
 app/javascript/mastodon/actions/streaming.js       |   1 +
 app/javascript/mastodon/actions/timelines.js       |   2 +
 .../containers/column_settings_container.js        |  17 ++++
 .../mastodon/features/direct_timeline/index.js     | 107 +++++++++++++++++++++
 .../mastodon/features/getting_started/index.js     |  15 ++-
 .../features/ui/components/columns_area.js         |   3 +-
 app/javascript/mastodon/features/ui/index.js       |   2 +
 .../mastodon/features/ui/util/async-components.js  |   4 +
 .../mastodon/locales/defaultMessages.json          |  17 ++++
 app/javascript/mastodon/locales/en.json            |   3 +
 app/javascript/mastodon/reducers/settings.js       |   6 ++
 app/models/status.rb                               |   8 ++
 app/services/batched_remove_status_service.rb      |  11 +++
 app/services/fan_out_on_write_service.rb           |  13 ++-
 app/services/remove_status_service.rb              |   8 ++
 config/routes.rb                                   |   1 +
 spec/models/status_spec.rb                         |  49 ++++++++++
 streaming/index.js                                 |   7 ++
 20 files changed, 329 insertions(+), 7 deletions(-)
 create mode 100644 app/controllers/api/v1/timelines/direct_controller.rb
 create mode 100644 app/javascript/mastodon/features/direct_timeline/containers/column_settings_container.js
 create mode 100644 app/javascript/mastodon/features/direct_timeline/index.js

(limited to 'app/models')

diff --git a/app/controllers/api/v1/timelines/direct_controller.rb b/app/controllers/api/v1/timelines/direct_controller.rb
new file mode 100644
index 000000000..d455227eb
--- /dev/null
+++ b/app/controllers/api/v1/timelines/direct_controller.rb
@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class Api::V1::Timelines::DirectController < Api::BaseController
+  before_action -> { doorkeeper_authorize! :read }, only: [:show]
+  before_action :require_user!, only: [:show]
+  after_action :insert_pagination_headers, unless: -> { @statuses.empty? }
+
+  respond_to :json
+
+  def show
+    @statuses = load_statuses
+    render json: @statuses, each_serializer: REST::StatusSerializer, relationships: StatusRelationshipsPresenter.new(@statuses, current_user&.account_id)
+  end
+
+  private
+
+  def load_statuses
+    cached_direct_statuses
+  end
+
+  def cached_direct_statuses
+    cache_collection direct_statuses, Status
+  end
+
+  def direct_statuses
+    direct_timeline_statuses.paginate_by_max_id(
+      limit_param(DEFAULT_STATUSES_LIMIT),
+      params[:max_id],
+      params[:since_id]
+    )
+  end
+
+  def direct_timeline_statuses
+    Status.as_direct_timeline(current_account)
+  end
+
+  def insert_pagination_headers
+    set_pagination_headers(next_path, prev_path)
+  end
+
+  def pagination_params(core_params)
+    params.permit(:local, :limit).merge(core_params)
+  end
+
+  def next_path
+    api_v1_timelines_direct_url pagination_params(max_id: pagination_max_id)
+  end
+
+  def prev_path
+    api_v1_timelines_direct_url pagination_params(since_id: pagination_since_id)
+  end
+
+  def pagination_max_id
+    @statuses.last.id
+  end
+
+  def pagination_since_id
+    @statuses.first.id
+  end
+end
diff --git a/app/javascript/mastodon/actions/compose.js b/app/javascript/mastodon/actions/compose.js
index 8a35049b3..278fbc898 100644
--- a/app/javascript/mastodon/actions/compose.js
+++ b/app/javascript/mastodon/actions/compose.js
@@ -128,6 +128,8 @@ export function submitCompose() {
       if (response.data.in_reply_to_id === null && response.data.visibility === 'public') {
         insertOrRefresh('community', refreshCommunityTimeline);
         insertOrRefresh('public', refreshPublicTimeline);
+      } else if (response.data.visibility === 'direct') {
+        dispatch(updateTimeline('direct', { ...response.data }));
       }
     }).catch(function (error) {
       dispatch(submitComposeFail(error));
diff --git a/app/javascript/mastodon/actions/streaming.js b/app/javascript/mastodon/actions/streaming.js
index 7802694a3..a2e25c930 100644
--- a/app/javascript/mastodon/actions/streaming.js
+++ b/app/javascript/mastodon/actions/streaming.js
@@ -92,3 +92,4 @@ export const connectCommunityStream = () => connectTimelineStream('community', '
 export const connectMediaStream = () => connectTimelineStream('community', 'public:local');
 export const connectPublicStream = () => connectTimelineStream('public', 'public');
 export const connectHashtagStream = (tag) => connectTimelineStream(`hashtag:${tag}`, `hashtag&tag=${tag}`);
+export const connectDirectStream = () => connectTimelineStream('direct', 'direct');
diff --git a/app/javascript/mastodon/actions/timelines.js b/app/javascript/mastodon/actions/timelines.js
index 09abe2702..935bbb6f0 100644
--- a/app/javascript/mastodon/actions/timelines.js
+++ b/app/javascript/mastodon/actions/timelines.js
@@ -115,6 +115,7 @@ export function refreshTimeline(timelineId, path, params = {}) {
 export const refreshHomeTimeline         = () => refreshTimeline('home', '/api/v1/timelines/home');
 export const refreshPublicTimeline       = () => refreshTimeline('public', '/api/v1/timelines/public');
 export const refreshCommunityTimeline    = () => refreshTimeline('community', '/api/v1/timelines/public', { local: true });
+export const refreshDirectTimeline       = () => refreshTimeline('direct', '/api/v1/timelines/direct');
 export const refreshAccountTimeline      = accountId => refreshTimeline(`account:${accountId}`, `/api/v1/accounts/${accountId}/statuses`);
 export const refreshAccountMediaTimeline = accountId => refreshTimeline(`account:${accountId}:media`, `/api/v1/accounts/${accountId}/statuses`, { only_media: true });
 export const refreshHashtagTimeline      = hashtag => refreshTimeline(`hashtag:${hashtag}`, `/api/v1/timelines/tag/${hashtag}`);
@@ -155,6 +156,7 @@ export function expandTimeline(timelineId, path, params = {}) {
 export const expandHomeTimeline         = () => expandTimeline('home', '/api/v1/timelines/home');
 export const expandPublicTimeline       = () => expandTimeline('public', '/api/v1/timelines/public');
 export const expandCommunityTimeline    = () => expandTimeline('community', '/api/v1/timelines/public', { local: true });
+export const expandDirectTimeline       = () => expandTimeline('direct', '/api/v1/timelines/direct');
 export const expandAccountTimeline      = accountId => expandTimeline(`account:${accountId}`, `/api/v1/accounts/${accountId}/statuses`);
 export const expandAccountMediaTimeline = accountId => expandTimeline(`account:${accountId}:media`, `/api/v1/accounts/${accountId}/statuses`, { only_media: true });
 export const expandHashtagTimeline      = hashtag => expandTimeline(`hashtag:${hashtag}`, `/api/v1/timelines/tag/${hashtag}`);
diff --git a/app/javascript/mastodon/features/direct_timeline/containers/column_settings_container.js b/app/javascript/mastodon/features/direct_timeline/containers/column_settings_container.js
new file mode 100644
index 000000000..1833f69e5
--- /dev/null
+++ b/app/javascript/mastodon/features/direct_timeline/containers/column_settings_container.js
@@ -0,0 +1,17 @@
+import { connect } from 'react-redux';
+import ColumnSettings from '../../community_timeline/components/column_settings';
+import { changeSetting } from '../../../actions/settings';
+
+const mapStateToProps = state => ({
+  settings: state.getIn(['settings', 'direct']),
+});
+
+const mapDispatchToProps = dispatch => ({
+
+  onChange (key, checked) {
+    dispatch(changeSetting(['direct', ...key], checked));
+  },
+
+});
+
+export default connect(mapStateToProps, mapDispatchToProps)(ColumnSettings);
diff --git a/app/javascript/mastodon/features/direct_timeline/index.js b/app/javascript/mastodon/features/direct_timeline/index.js
new file mode 100644
index 000000000..05e092ee0
--- /dev/null
+++ b/app/javascript/mastodon/features/direct_timeline/index.js
@@ -0,0 +1,107 @@
+import React from 'react';
+import { connect } from 'react-redux';
+import PropTypes from 'prop-types';
+import StatusListContainer from '../ui/containers/status_list_container';
+import Column from '../../components/column';
+import ColumnHeader from '../../components/column_header';
+import {
+  refreshDirectTimeline,
+  expandDirectTimeline,
+} from '../../actions/timelines';
+import { addColumn, removeColumn, moveColumn } from '../../actions/columns';
+import { defineMessages, injectIntl, FormattedMessage } from 'react-intl';
+import ColumnSettingsContainer from './containers/column_settings_container';
+import { connectDirectStream } from '../../actions/streaming';
+
+const messages = defineMessages({
+  title: { id: 'column.direct', defaultMessage: 'Direct messages' },
+});
+
+const mapStateToProps = state => ({
+  hasUnread: state.getIn(['timelines', 'direct', 'unread']) > 0,
+});
+
+@connect(mapStateToProps)
+@injectIntl
+export default class DirectTimeline extends React.PureComponent {
+
+  static propTypes = {
+    dispatch: PropTypes.func.isRequired,
+    columnId: PropTypes.string,
+    intl: PropTypes.object.isRequired,
+    hasUnread: PropTypes.bool,
+    multiColumn: PropTypes.bool,
+  };
+
+  handlePin = () => {
+    const { columnId, dispatch } = this.props;
+
+    if (columnId) {
+      dispatch(removeColumn(columnId));
+    } else {
+      dispatch(addColumn('DIRECT', {}));
+    }
+  }
+
+  handleMove = (dir) => {
+    const { columnId, dispatch } = this.props;
+    dispatch(moveColumn(columnId, dir));
+  }
+
+  handleHeaderClick = () => {
+    this.column.scrollTop();
+  }
+
+  componentDidMount () {
+    const { dispatch } = this.props;
+
+    dispatch(refreshDirectTimeline());
+    this.disconnect = dispatch(connectDirectStream());
+  }
+
+  componentWillUnmount () {
+    if (this.disconnect) {
+      this.disconnect();
+      this.disconnect = null;
+    }
+  }
+
+  setRef = c => {
+    this.column = c;
+  }
+
+  handleLoadMore = () => {
+    this.props.dispatch(expandDirectTimeline());
+  }
+
+  render () {
+    const { intl, hasUnread, columnId, multiColumn } = this.props;
+    const pinned = !!columnId;
+
+    return (
+      <Column ref={this.setRef}>
+        <ColumnHeader
+          icon='envelope'
+          active={hasUnread}
+          title={intl.formatMessage(messages.title)}
+          onPin={this.handlePin}
+          onMove={this.handleMove}
+          onClick={this.handleHeaderClick}
+          pinned={pinned}
+          multiColumn={multiColumn}
+        >
+          <ColumnSettingsContainer />
+        </ColumnHeader>
+
+        <StatusListContainer
+          trackScroll={!pinned}
+          scrollKey={`direct_timeline-${columnId}`}
+          timelineId='direct'
+          loadMore={this.handleLoadMore}
+          emptyMessage={<FormattedMessage id='empty_column.direct' defaultMessage="You don't have any direct messages yet. When you send or receive one, it will show up here." />}
+        />
+      </Column>
+    );
+  }
+
+}
diff --git a/app/javascript/mastodon/features/getting_started/index.js b/app/javascript/mastodon/features/getting_started/index.js
index 973c8a4ae..94dabd4ad 100644
--- a/app/javascript/mastodon/features/getting_started/index.js
+++ b/app/javascript/mastodon/features/getting_started/index.js
@@ -16,6 +16,7 @@ const messages = defineMessages({
   navigation_subheading: { id: 'column_subheading.navigation', defaultMessage: 'Navigation' },
   settings_subheading: { id: 'column_subheading.settings', defaultMessage: 'Settings' },
   community_timeline: { id: 'navigation_bar.community_timeline', defaultMessage: 'Local timeline' },
+  direct: { id: 'navigation_bar.direct', defaultMessage: 'Direct messages' },
   preferences: { id: 'navigation_bar.preferences', defaultMessage: 'Preferences' },
   follow_requests: { id: 'navigation_bar.follow_requests', defaultMessage: 'Follow requests' },
   sign_out: { id: 'navigation_bar.logout', defaultMessage: 'Logout' },
@@ -65,18 +66,22 @@ export default class GettingStarted extends ImmutablePureComponent {
       }
     }
 
+    if (!multiColumn || !columns.find(item => item.get('id') === 'DIRECT')) {
+      navItems.push(<ColumnLink key='4' icon='envelope' text={intl.formatMessage(messages.direct)} to='/timelines/direct' />);
+    }
+
     navItems = navItems.concat([
-      <ColumnLink key='4' icon='star' text={intl.formatMessage(messages.favourites)} to='/favourites' />,
-      <ColumnLink key='5' icon='thumb-tack' text={intl.formatMessage(messages.pins)} to='/pinned' />,
+      <ColumnLink key='5' icon='star' text={intl.formatMessage(messages.favourites)} to='/favourites' />,
+      <ColumnLink key='6' icon='thumb-tack' text={intl.formatMessage(messages.pins)} to='/pinned' />,
     ]);
 
     if (me.get('locked')) {
-      navItems.push(<ColumnLink key='6' icon='users' text={intl.formatMessage(messages.follow_requests)} to='/follow_requests' />);
+      navItems.push(<ColumnLink key='7' icon='users' text={intl.formatMessage(messages.follow_requests)} to='/follow_requests' />);
     }
 
     navItems = navItems.concat([
-      <ColumnLink key='7' icon='volume-off' text={intl.formatMessage(messages.mutes)} to='/mutes' />,
-      <ColumnLink key='8' icon='ban' text={intl.formatMessage(messages.blocks)} to='/blocks' />,
+      <ColumnLink key='8' icon='volume-off' text={intl.formatMessage(messages.mutes)} to='/mutes' />,
+      <ColumnLink key='9' icon='ban' text={intl.formatMessage(messages.blocks)} to='/blocks' />,
     ]);
 
     return (
diff --git a/app/javascript/mastodon/features/ui/components/columns_area.js b/app/javascript/mastodon/features/ui/components/columns_area.js
index 5610095b9..ee1064229 100644
--- a/app/javascript/mastodon/features/ui/components/columns_area.js
+++ b/app/javascript/mastodon/features/ui/components/columns_area.js
@@ -11,7 +11,7 @@ import BundleContainer from '../containers/bundle_container';
 import ColumnLoading from './column_loading';
 import DrawerLoading from './drawer_loading';
 import BundleColumnError from './bundle_column_error';
-import { Compose, Notifications, HomeTimeline, CommunityTimeline, PublicTimeline, HashtagTimeline, FavouritedStatuses } from '../../ui/util/async-components';
+import { Compose, Notifications, HomeTimeline, CommunityTimeline, PublicTimeline, HashtagTimeline, DirectTimeline, FavouritedStatuses } from '../../ui/util/async-components';
 
 import detectPassiveEvents from 'detect-passive-events';
 import { scrollRight } from '../../../scroll';
@@ -23,6 +23,7 @@ const componentMap = {
   'PUBLIC': PublicTimeline,
   'COMMUNITY': CommunityTimeline,
   'HASHTAG': HashtagTimeline,
+  'DIRECT': DirectTimeline,
   'FAVOURITES': FavouritedStatuses,
 };
 
diff --git a/app/javascript/mastodon/features/ui/index.js b/app/javascript/mastodon/features/ui/index.js
index 70e451373..cf51f0fb6 100644
--- a/app/javascript/mastodon/features/ui/index.js
+++ b/app/javascript/mastodon/features/ui/index.js
@@ -28,6 +28,7 @@ import {
   Following,
   Reblogs,
   Favourites,
+  DirectTimeline,
   HashtagTimeline,
   Notifications,
   FollowRequests,
@@ -350,6 +351,7 @@ export default class UI extends React.Component {
               <WrappedRoute path='/timelines/home' component={HomeTimeline} content={children} />
               <WrappedRoute path='/timelines/public' exact component={PublicTimeline} content={children} />
               <WrappedRoute path='/timelines/public/local' component={CommunityTimeline} content={children} />
+              <WrappedRoute path='/timelines/direct' component={DirectTimeline} content={children} />
               <WrappedRoute path='/timelines/tag/:id' component={HashtagTimeline} content={children} />
 
               <WrappedRoute path='/notifications' component={Notifications} content={children} />
diff --git a/app/javascript/mastodon/features/ui/util/async-components.js b/app/javascript/mastodon/features/ui/util/async-components.js
index 8f7b91d21..f86c2266c 100644
--- a/app/javascript/mastodon/features/ui/util/async-components.js
+++ b/app/javascript/mastodon/features/ui/util/async-components.js
@@ -26,6 +26,10 @@ export function HashtagTimeline () {
   return import(/* webpackChunkName: "features/hashtag_timeline" */'../../hashtag_timeline');
 }
 
+export function DirectTimeline() {
+  return import(/* webpackChunkName: "features/direct_timeline" */'../../direct_timeline');
+}
+
 export function Status () {
   return import(/* webpackChunkName: "features/status" */'../../status');
 }
diff --git a/app/javascript/mastodon/locales/defaultMessages.json b/app/javascript/mastodon/locales/defaultMessages.json
index f400b283f..ebb514e69 100644
--- a/app/javascript/mastodon/locales/defaultMessages.json
+++ b/app/javascript/mastodon/locales/defaultMessages.json
@@ -755,6 +755,19 @@
     ],
     "path": "app/javascript/mastodon/features/compose/index.json"
   },
+  {
+    "descriptors": [
+      {
+        "defaultMessage": "Direct messages",
+        "id": "column.direct"
+      },
+      {
+        "defaultMessage": "You don't have any direct messages yet. When you send or receive one, it will show up here.",
+        "id": "empty_column.direct"
+      }
+    ],
+    "path": "app/javascript/mastodon/features/direct_timeline/index.json"
+  },
   {
     "descriptors": [
       {
@@ -816,6 +829,10 @@
         "defaultMessage": "Local timeline",
         "id": "navigation_bar.community_timeline"
       },
+      {
+        "defaultMessage": "Direct messages",
+        "id": "navigation_bar.direct"
+      },
       {
         "defaultMessage": "Preferences",
         "id": "navigation_bar.preferences"
diff --git a/app/javascript/mastodon/locales/en.json b/app/javascript/mastodon/locales/en.json
index 1d0bbcee5..efe0e1de9 100644
--- a/app/javascript/mastodon/locales/en.json
+++ b/app/javascript/mastodon/locales/en.json
@@ -28,6 +28,7 @@
   "bundle_modal_error.retry": "Try again",
   "column.blocks": "Blocked users",
   "column.community": "Local timeline",
+  "column.direct": "Direct messages",
   "column.favourites": "Favourites",
   "column.follow_requests": "Follow requests",
   "column.home": "Home",
@@ -80,6 +81,7 @@
   "emoji_button.symbols": "Symbols",
   "emoji_button.travel": "Travel & Places",
   "empty_column.community": "The local timeline is empty. Write something publicly to get the ball rolling!",
+  "empty_column.direct": "You don't have any direct messages yet. When you send or receive one, it will show up here.",
   "empty_column.hashtag": "There is nothing in this hashtag yet.",
   "empty_column.home": "Your home timeline is empty! Visit {public} or use search to get started and meet other users.",
   "empty_column.home.public_timeline": "the public timeline",
@@ -106,6 +108,7 @@
   "missing_indicator.label": "Not found",
   "navigation_bar.blocks": "Blocked users",
   "navigation_bar.community_timeline": "Local timeline",
+  "navigation_bar.direct": "Direct messages",
   "navigation_bar.edit_profile": "Edit profile",
   "navigation_bar.favourites": "Favourites",
   "navigation_bar.follow_requests": "Follow requests",
diff --git a/app/javascript/mastodon/reducers/settings.js b/app/javascript/mastodon/reducers/settings.js
index a9f3f9529..8b8bf165a 100644
--- a/app/javascript/mastodon/reducers/settings.js
+++ b/app/javascript/mastodon/reducers/settings.js
@@ -57,6 +57,12 @@ const initialState = ImmutableMap({
       body: '',
     }),
   }),
+
+  direct: ImmutableMap({
+    regex: ImmutableMap({
+      body: '',
+    }),
+  }),
 });
 
 const defaultColumns = fromJS([
diff --git a/app/models/status.rb b/app/models/status.rb
index 5a7245613..346282e2a 100644
--- a/app/models/status.rb
+++ b/app/models/status.rb
@@ -154,6 +154,14 @@ class Status < ApplicationRecord
       where(account: [account] + account.following).where(visibility: [:public, :unlisted, :private])
     end
 
+    def as_direct_timeline(account)
+      query = joins("LEFT OUTER JOIN mentions ON statuses.id = mentions.status_id AND mentions.account_id = #{account.id}")
+              .where("mentions.account_id = #{account.id} OR statuses.account_id = #{account.id}")
+              .where(visibility: [:direct])
+
+      apply_timeline_filters(query, account, false)
+    end
+
     def as_public_timeline(account = nil, local_only = false)
       query = timeline_scope(local_only).without_replies
 
diff --git a/app/services/batched_remove_status_service.rb b/app/services/batched_remove_status_service.rb
index 5d83771c9..aa2229f13 100644
--- a/app/services/batched_remove_status_service.rb
+++ b/app/services/batched_remove_status_service.rb
@@ -40,6 +40,7 @@ class BatchedRemoveStatusService < BaseService
     # Cannot be batched
     statuses.each do |status|
       unpush_from_public_timelines(status)
+      unpush_from_direct_timelines(status) if status.direct_visibility?
       batch_salmon_slaps(status) if status.local?
     end
 
@@ -100,6 +101,16 @@ class BatchedRemoveStatusService < BaseService
     end
   end
 
+  def unpush_from_direct_timelines(status)
+    payload = @json_payloads[status.id]
+    redis.pipelined do
+      @mentions[status.id].each do |mention|
+        redis.publish("timeline:direct:#{mention.account.id}", payload) if mention.account.local?
+      end
+      redis.publish("timeline:direct:#{status.account.id}", payload) if status.account.local?
+    end
+  end
+
   def batch_salmon_slaps(status)
     return if @mentions[status.id].empty?
 
diff --git a/app/services/fan_out_on_write_service.rb b/app/services/fan_out_on_write_service.rb
index 47a47a735..2214d73dd 100644
--- a/app/services/fan_out_on_write_service.rb
+++ b/app/services/fan_out_on_write_service.rb
@@ -10,15 +10,17 @@ class FanOutOnWriteService < BaseService
 
     deliver_to_self(status) if status.account.local?
 
+    render_anonymous_payload(status)
+
     if status.direct_visibility?
       deliver_to_mentioned_followers(status)
+      deliver_to_direct_timelines(status)
     else
       deliver_to_followers(status)
     end
 
     return if status.account.silenced? || !status.public_visibility? || status.reblog?
 
-    render_anonymous_payload(status)
     deliver_to_hashtags(status)
 
     return if status.reply? && status.in_reply_to_account_id != status.account_id
@@ -73,4 +75,13 @@ class FanOutOnWriteService < BaseService
     Redis.current.publish('timeline:public', @payload)
     Redis.current.publish('timeline:public:local', @payload) if status.local?
   end
+
+  def deliver_to_direct_timelines(status)
+    Rails.logger.debug "Delivering status #{status.id} to direct timelines"
+
+    status.mentions.includes(:account).each do |mention|
+      Redis.current.publish("timeline:direct:#{mention.account.id}", @payload) if mention.account.local?
+    end
+    Redis.current.publish("timeline:direct:#{status.account.id}", @payload) if status.account.local?
+  end
 end
diff --git a/app/services/remove_status_service.rb b/app/services/remove_status_service.rb
index 96d9208cc..8eef3e57e 100644
--- a/app/services/remove_status_service.rb
+++ b/app/services/remove_status_service.rb
@@ -18,6 +18,7 @@ class RemoveStatusService < BaseService
     remove_reblogs
     remove_from_hashtags
     remove_from_public
+    remove_from_direct if status.direct_visibility?
 
     @status.destroy!
 
@@ -121,6 +122,13 @@ class RemoveStatusService < BaseService
     Redis.current.publish('timeline:public:local', @payload) if @status.local?
   end
 
+  def remove_from_direct
+    @mentions.each do |mention|
+      Redis.current.publish("timeline:direct:#{mention.account.id}", @payload) if mention.account.local?
+    end
+    Redis.current.publish("timeline:direct:#{@account.id}", @payload) if @account.local?
+  end
+
   def redis
     Redis.current
   end
diff --git a/config/routes.rb b/config/routes.rb
index 5a6351f77..8263c477b 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -193,6 +193,7 @@ Rails.application.routes.draw do
       end
 
       namespace :timelines do
+        resource :direct, only: :show, controller: :direct
         resource :home, only: :show, controller: :home
         resource :public, only: :show, controller: :public
         resources :tag, only: :show
diff --git a/spec/models/status_spec.rb b/spec/models/status_spec.rb
index 9cb71d715..12e857169 100644
--- a/spec/models/status_spec.rb
+++ b/spec/models/status_spec.rb
@@ -232,6 +232,55 @@ RSpec.describe Status, type: :model do
     end
   end
 
+  describe '.as_direct_timeline' do
+    let(:account) { Fabricate(:account) }
+    let(:followed) { Fabricate(:account) }
+    let(:not_followed) { Fabricate(:account) }
+
+    before do
+      Fabricate(:follow, account: account, target_account: followed)
+
+      @self_public_status = Fabricate(:status, account: account, visibility: :public)
+      @self_direct_status = Fabricate(:status, account: account, visibility: :direct)
+      @followed_public_status = Fabricate(:status, account: followed, visibility: :public)
+      @followed_direct_status = Fabricate(:status, account: followed, visibility: :direct)
+      @not_followed_direct_status = Fabricate(:status, account: not_followed, visibility: :direct)
+
+      @results = Status.as_direct_timeline(account)
+    end
+
+    it 'does not include public statuses from self' do
+      expect(@results).to_not include(@self_public_status)
+    end
+
+    it 'includes direct statuses from self' do
+      expect(@results).to include(@self_direct_status)
+    end
+
+    it 'does not include public statuses from followed' do
+      expect(@results).to_not include(@followed_public_status)
+    end
+
+    it 'includes direct statuses mentioning recipient from followed' do
+      Fabricate(:mention, account: account, status: @followed_direct_status)
+      expect(@results).to include(@followed_direct_status)
+    end
+
+    it 'does not include direct statuses not mentioning recipient from followed' do
+      expect(@results).to_not include(@followed_direct_status)
+    end
+
+    it 'includes direct statuses mentioning recipient from non-followed' do
+      Fabricate(:mention, account: account, status: @not_followed_direct_status)
+      expect(@results).to include(@not_followed_direct_status)
+    end
+
+    it 'does not include direct statuses not mentioning recipient from non-followed' do
+      expect(@results).to_not include(@not_followed_direct_status)
+    end
+
+  end
+
   describe '.as_public_timeline' do
     it 'only includes statuses with public visibility' do
       public_status = Fabricate(:status, visibility: :public)
diff --git a/streaming/index.js b/streaming/index.js
index 83903b89b..8adc5174a 100644
--- a/streaming/index.js
+++ b/streaming/index.js
@@ -402,6 +402,10 @@ const startWorker = (workerId) => {
     streamFrom('timeline:public:local', req, streamToHttp(req, res), streamHttpEnd(req), true);
   });
 
+  app.get('/api/v1/streaming/direct', (req, res) => {
+    streamFrom(`timeline:direct:${req.accountId}`, req, streamToHttp(req, res), streamHttpEnd(req), true);
+  });
+
   app.get('/api/v1/streaming/hashtag', (req, res) => {
     streamFrom(`timeline:hashtag:${req.query.tag.toLowerCase()}`, req, streamToHttp(req, res), streamHttpEnd(req), true);
   });
@@ -437,6 +441,9 @@ const startWorker = (workerId) => {
     case 'public:local':
       streamFrom('timeline:public:local', req, streamToWs(req, ws), streamWsEnd(req, ws), true);
       break;
+    case 'direct':
+      streamFrom(`timeline:direct:${req.accountId}`, req, streamToWs(req, ws), streamWsEnd(req, ws), true);
+      break;
     case 'hashtag':
       streamFrom(`timeline:hashtag:${location.query.tag.toLowerCase()}`, req, streamToWs(req, ws), streamWsEnd(req, ws), true);
       break;
-- 
cgit 


From 8410d33b49d66683f5765b6c6ee5a4a1af5b098f Mon Sep 17 00:00:00 2001
From: David Yip <yipdw@member.fsf.org>
Date: Mon, 23 Oct 2017 19:31:59 -0500
Subject: Only cache the regex text, not the regex itself.

It is possible to cache a Regexp object, but I'm not sure what happens
if e.g. that object remains in cache across two different Ruby versions.
Caching a string seems to raise fewer questions.
---
 app/models/glitch/keyword_mute.rb | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

(limited to 'app/models')

diff --git a/app/models/glitch/keyword_mute.rb b/app/models/glitch/keyword_mute.rb
index a7ab3650e..4c3e69de4 100644
--- a/app/models/glitch/keyword_mute.rb
+++ b/app/models/glitch/keyword_mute.rb
@@ -34,23 +34,20 @@ class Glitch::KeywordMute < ApplicationRecord
 
     def initialize(account_id)
       @account_id = account_id
-      @regex = Rails.cache.fetch("keyword_mutes:regex:#{account_id}") { regex_for_account }
+      regex_text = Rails.cache.fetch("keyword_mutes:regex:#{account_id}") { regex_text_for_account }
+      @regex = /#{regex_text}/i unless regex_text.empty?
     end
 
     def keywords
-      Glitch::KeywordMute.
-        where(account_id: account_id).
-        select(:keyword, :id, :whole_word)
+      Glitch::KeywordMute.where(account_id: account_id).select(:keyword, :id, :whole_word)
     end
 
-    def regex_for_account
-      re_text = [].tap do |arr|
+    def regex_text_for_account
+      [].tap do |arr|
         keywords.find_each do |kw|
           arr << (kw.whole_word ? boundary_regex_for_keyword(kw.keyword) : Regexp.escape(kw.keyword))
         end
       end.join('|')
-
-      /#{re_text}/i unless re_text.empty?
     end
 
     def boundary_regex_for_keyword(keyword)
-- 
cgit 


From f5a32839761f4951dc09ecbf207573183c6e2f80 Mon Sep 17 00:00:00 2001
From: David Yip <yipdw@member.fsf.org>
Date: Tue, 24 Oct 2017 18:31:34 -0500
Subject: Switch to Regexp.union for building the mute expression.

Also make the keyword-building methods private: they always probably
should have been private, but now I have encoded enough fun and games
into them that it now seems wrong for them to *not* be private.
---
 app/models/glitch/keyword_mute.rb | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

(limited to 'app/models')

diff --git a/app/models/glitch/keyword_mute.rb b/app/models/glitch/keyword_mute.rb
index 4c3e69de4..f0969c65e 100644
--- a/app/models/glitch/keyword_mute.rb
+++ b/app/models/glitch/keyword_mute.rb
@@ -35,30 +35,32 @@ class Glitch::KeywordMute < ApplicationRecord
     def initialize(account_id)
       @account_id = account_id
       regex_text = Rails.cache.fetch("keyword_mutes:regex:#{account_id}") { regex_text_for_account }
-      @regex = /#{regex_text}/i unless regex_text.empty?
+      @regex = /#{regex_text}/i
     end
 
+    def =~(str)
+      regex ? regex =~ str : nil
+    end
+
+    private
+
     def keywords
       Glitch::KeywordMute.where(account_id: account_id).select(:keyword, :id, :whole_word)
     end
 
     def regex_text_for_account
-      [].tap do |arr|
-        keywords.find_each do |kw|
-          arr << (kw.whole_word ? boundary_regex_for_keyword(kw.keyword) : Regexp.escape(kw.keyword))
-        end
-      end.join('|')
+      kws = keywords.find_each.with_object([]) do |kw, a|
+        a << (kw.whole_word ? boundary_regex_for_keyword(kw.keyword) : kw.keyword)
+      end
+
+      Regexp.union(kws).source
     end
 
     def boundary_regex_for_keyword(keyword)
       sb = keyword =~ /\A[[:word:]]/ ? '\b' : ''
       eb = keyword =~ /[[:word:]]\Z/ ? '\b' : ''
 
-      "#{sb}#{Regexp.escape(keyword)}#{eb}"
-    end
-
-    def =~(str)
-      regex ? regex =~ str : nil
+      /#{sb}#{Regexp.escape(keyword)}#{eb}/
     end
   end
 end
-- 
cgit 


From e40fe4092dfd927dd4b6605b7b398fcd0984d903 Mon Sep 17 00:00:00 2001
From: David Yip <yipdw@member.fsf.org>
Date: Tue, 24 Oct 2017 19:03:59 -0500
Subject: Remove nil check in Glitch::KeywordMute#=~.

@regex can no longer be nil, so we don't need to check it.
---
 app/models/glitch/keyword_mute.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'app/models')

diff --git a/app/models/glitch/keyword_mute.rb b/app/models/glitch/keyword_mute.rb
index f0969c65e..73de4d4b7 100644
--- a/app/models/glitch/keyword_mute.rb
+++ b/app/models/glitch/keyword_mute.rb
@@ -39,7 +39,7 @@ class Glitch::KeywordMute < ApplicationRecord
     end
 
     def =~(str)
-      regex ? regex =~ str : nil
+      regex =~ str
     end
 
     private
-- 
cgit 


From 49445150202f0bdaae942b9ae1ba44802a1c22e9 Mon Sep 17 00:00:00 2001
From: aschmitz <aschmitz@lardbucket.org>
Date: Thu, 9 Nov 2017 08:41:10 -0600
Subject: "Show reblogs" per-follower UI/database changes

TODO:

* Tests (particularly for FollowRequests).
* Anything to respect the setting when putting reblogs in timelines.
---
 app/controllers/api/v1/accounts_controller.rb      |  6 +++--
 app/javascript/glitch/components/account/header.js |  2 +-
 app/javascript/mastodon/actions/accounts.js        |  4 +--
 app/javascript/mastodon/components/account.js      |  2 +-
 .../features/account/components/action_bar.js      | 12 +++++++++
 .../features/account_timeline/components/header.js |  6 +++++
 .../containers/header_container.js                 |  8 ++++++
 app/models/concerns/account_interactions.rb        | 23 +++++++++++++---
 app/models/follow.rb                               |  1 +
 app/models/follow_request.rb                       |  3 ++-
 app/services/follow_service.rb                     | 31 ++++++++++++++++------
 db/schema.rb                                       |  4 ++-
 12 files changed, 82 insertions(+), 20 deletions(-)

(limited to 'app/models')

diff --git a/app/controllers/api/v1/accounts_controller.rb b/app/controllers/api/v1/accounts_controller.rb
index 4676f60de..afdbf6e2d 100644
--- a/app/controllers/api/v1/accounts_controller.rb
+++ b/app/controllers/api/v1/accounts_controller.rb
@@ -13,9 +13,11 @@ class Api::V1::AccountsController < Api::BaseController
   end
 
   def follow
-    FollowService.new.call(current_user.account, @account.acct)
+    reblogs_arg = { reblogs: params[:reblogs] }
+    
+    FollowService.new.call(current_user.account, @account.acct, reblogs_arg)
 
-    options = @account.locked? ? {} : { following_map: { @account.id => true }, requested_map: { @account.id => false } }
+    options = @account.locked? ? {} : { following_map: reblogs_arg, requested_map: { @account.id => false } }
 
     render json: @account, serializer: REST::RelationshipSerializer, relationships: relationships(options)
   end
diff --git a/app/javascript/glitch/components/account/header.js b/app/javascript/glitch/components/account/header.js
index f4a413aa3..c94fb0851 100644
--- a/app/javascript/glitch/components/account/header.js
+++ b/app/javascript/glitch/components/account/header.js
@@ -152,7 +152,7 @@ appropriate icon.
             <IconButton
               size={26}
               icon={following ? 'user-times' : 'user-plus'}
-              active={following}
+              active={following ? true : false}
               title={intl.formatMessage(following ? messages.unfollow : messages.follow)}
               onClick={this.props.onFollow}
             />
diff --git a/app/javascript/mastodon/actions/accounts.js b/app/javascript/mastodon/actions/accounts.js
index fbaebf786..cabf72bde 100644
--- a/app/javascript/mastodon/actions/accounts.js
+++ b/app/javascript/mastodon/actions/accounts.js
@@ -105,11 +105,11 @@ export function fetchAccountFail(id, error) {
   };
 };
 
-export function followAccount(id) {
+export function followAccount(id, reblogs = true) {
   return (dispatch, getState) => {
     dispatch(followAccountRequest(id));
 
-    api(getState).post(`/api/v1/accounts/${id}/follow`).then(response => {
+    api(getState).post(`/api/v1/accounts/${id}/follow`, { reblogs }).then(response => {
       dispatch(followAccountSuccess(response.data));
     }).catch(error => {
       dispatch(followAccountFail(error));
diff --git a/app/javascript/mastodon/components/account.js b/app/javascript/mastodon/components/account.js
index 7cdb8c672..376e544fb 100644
--- a/app/javascript/mastodon/components/account.js
+++ b/app/javascript/mastodon/components/account.js
@@ -93,7 +93,7 @@ export default class Account extends ImmutablePureComponent {
           </div>
         );
       } else {
-        buttons = <IconButton icon={following ? 'user-times' : 'user-plus'} title={intl.formatMessage(following ? messages.unfollow : messages.follow)} onClick={this.handleFollow} active={following} />;
+        buttons = <IconButton icon={following ? 'user-times' : 'user-plus'} title={intl.formatMessage(following ? messages.unfollow : messages.follow)} onClick={this.handleFollow} active={following ? true : false} />;
       }
     }
 
diff --git a/app/javascript/mastodon/features/account/components/action_bar.js b/app/javascript/mastodon/features/account/components/action_bar.js
index 2819ae252..718e7fbad 100644
--- a/app/javascript/mastodon/features/account/components/action_bar.js
+++ b/app/javascript/mastodon/features/account/components/action_bar.js
@@ -19,6 +19,8 @@ const messages = defineMessages({
   media: { id: 'account.media', defaultMessage: 'Media' },
   blockDomain: { id: 'account.block_domain', defaultMessage: 'Hide everything from {domain}' },
   unblockDomain: { id: 'account.unblock_domain', defaultMessage: 'Unhide {domain}' },
+  hideReblogs: { id: 'account.hide_reblogs', defaultMessage: 'Hide boosts from @{name}' },
+  showReblogs: { id: 'account.show_reblogs', defaultMessage: 'Show boosts from @{name}' },
 });
 
 @injectIntl
@@ -30,6 +32,7 @@ export default class ActionBar extends React.PureComponent {
     onFollow: PropTypes.func,
     onBlock: PropTypes.func.isRequired,
     onMention: PropTypes.func.isRequired,
+    onReblogToggle: PropTypes.func.isRequired,
     onReport: PropTypes.func.isRequired,
     onMute: PropTypes.func.isRequired,
     onBlockDomain: PropTypes.func.isRequired,
@@ -60,6 +63,15 @@ export default class ActionBar extends React.PureComponent {
     if (account.get('id') === me) {
       menu.push({ text: intl.formatMessage(messages.edit_profile), href: '/settings/profile' });
     } else {
+      const following = account.getIn(['relationship', 'following']);
+      if (following) {
+        if (following.get('reblogs')) {
+          menu.push({ text: intl.formatMessage(messages.hideReblogs, { name: account.get('username') }), action: this.props.onReblogToggle });
+        } else {
+          menu.push({ text: intl.formatMessage(messages.showReblogs, { name: account.get('username') }), action: this.props.onReblogToggle });
+        }
+      }
+
       if (account.getIn(['relationship', 'muting'])) {
         menu.push({ text: intl.formatMessage(messages.unmute, { name: account.get('username') }), action: this.props.onMute });
       } else {
diff --git a/app/javascript/mastodon/features/account_timeline/components/header.js b/app/javascript/mastodon/features/account_timeline/components/header.js
index c3cd4e55d..b33df282f 100644
--- a/app/javascript/mastodon/features/account_timeline/components/header.js
+++ b/app/javascript/mastodon/features/account_timeline/components/header.js
@@ -14,6 +14,7 @@ export default class Header extends ImmutablePureComponent {
     onFollow: PropTypes.func.isRequired,
     onBlock: PropTypes.func.isRequired,
     onMention: PropTypes.func.isRequired,
+    onReblogToggle: PropTypes.func.isRequired,
     onReport: PropTypes.func.isRequired,
     onMute: PropTypes.func.isRequired,
     onBlockDomain: PropTypes.func.isRequired,
@@ -40,6 +41,10 @@ export default class Header extends ImmutablePureComponent {
     this.props.onReport(this.props.account);
   }
 
+  handleReblogToggle = () => {
+    this.props.onReblogToggle(this.props.account);
+  }
+
   handleMute = () => {
     this.props.onMute(this.props.account);
   }
@@ -80,6 +85,7 @@ export default class Header extends ImmutablePureComponent {
           me={me}
           onBlock={this.handleBlock}
           onMention={this.handleMention}
+          onReblogToggle={this.handleReblogToggle}
           onReport={this.handleReport}
           onMute={this.handleMute}
           onBlockDomain={this.handleBlockDomain}
diff --git a/app/javascript/mastodon/features/account_timeline/containers/header_container.js b/app/javascript/mastodon/features/account_timeline/containers/header_container.js
index 9ad13a231..68c037e9b 100644
--- a/app/javascript/mastodon/features/account_timeline/containers/header_container.js
+++ b/app/javascript/mastodon/features/account_timeline/containers/header_container.js
@@ -68,6 +68,14 @@ const mapDispatchToProps = (dispatch, { intl }) => ({
     dispatch(mentionCompose(account, router));
   },
 
+  onReblogToggle (account) {
+    if (account.getIn(['relationship', 'following', 'reblogs'])) {
+      dispatch(followAccount(account.get('id'), false));
+    } else {
+      dispatch(followAccount(account.get('id'), true));
+    }
+  },
+
   onReport (account) {
     dispatch(initReport(account));
   },
diff --git a/app/models/concerns/account_interactions.rb b/app/models/concerns/account_interactions.rb
index 0afdebf89..088fef4da 100644
--- a/app/models/concerns/account_interactions.rb
+++ b/app/models/concerns/account_interactions.rb
@@ -5,7 +5,11 @@ module AccountInteractions
 
   class_methods do
     def following_map(target_account_ids, account_id)
-      follow_mapping(Follow.where(target_account_id: target_account_ids, account_id: account_id), :target_account_id)
+      Follow.where(target_account_id: target_account_ids, account_id: account_id).each_with_object({}) do |follow, mapping|
+        mapping[follow.target_account_id] = {
+          reblogs: follow.show_reblogs?
+        }
+      end
     end
 
     def followed_by_map(target_account_ids, account_id)
@@ -25,7 +29,11 @@ module AccountInteractions
     end
 
     def requested_map(target_account_ids, account_id)
-      follow_mapping(FollowRequest.where(target_account_id: target_account_ids, account_id: account_id), :target_account_id)
+      FollowRequest.where(target_account_id: target_account_ids, account_id: account_id).each_with_object({}) do |follow_request, mapping|
+        mapping[follow_request.target_account_id] = {
+          reblogs: follow_request.show_reblogs?
+        }
+      end
     end
 
     def domain_blocking_map(target_account_ids, account_id)
@@ -66,8 +74,15 @@ module AccountInteractions
     has_many :domain_blocks, class_name: 'AccountDomainBlock', dependent: :destroy
   end
 
-  def follow!(other_account)
-    active_relationships.find_or_create_by!(target_account: other_account)
+  def follow!(other_account, reblogs: nil)
+    reblogs = true if reblogs.nil?
+    rel = active_relationships.create_with(show_reblogs: reblogs).find_or_create_by!(target_account: other_account)
+    if rel.show_reblogs != reblogs
+      rel.show_reblogs = reblogs
+      rel.save!
+    end
+    
+    rel
   end
 
   def block!(other_account)
diff --git a/app/models/follow.rb b/app/models/follow.rb
index 667720a88..a8ddcb7f0 100644
--- a/app/models/follow.rb
+++ b/app/models/follow.rb
@@ -8,6 +8,7 @@
 #  account_id        :integer          not null
 #  id                :integer          not null, primary key
 #  target_account_id :integer          not null
+#  show_reblogs      :boolean          default(TRUE), not null
 #
 
 class Follow < ApplicationRecord
diff --git a/app/models/follow_request.rb b/app/models/follow_request.rb
index 60036d903..0608ffabc 100644
--- a/app/models/follow_request.rb
+++ b/app/models/follow_request.rb
@@ -8,6 +8,7 @@
 #  account_id        :integer          not null
 #  id                :integer          not null, primary key
 #  target_account_id :integer          not null
+#  show_reblogs      :boolean          default(TRUE), not null
 #
 
 class FollowRequest < ApplicationRecord
@@ -21,7 +22,7 @@ class FollowRequest < ApplicationRecord
   validates :account_id, uniqueness: { scope: :target_account_id }
 
   def authorize!
-    account.follow!(target_account)
+    account.follow!(target_account, reblogs: reblogs)
     MergeWorker.perform_async(target_account.id, account.id)
 
     destroy!
diff --git a/app/services/follow_service.rb b/app/services/follow_service.rb
index 791773f25..70572110d 100644
--- a/app/services/follow_service.rb
+++ b/app/services/follow_service.rb
@@ -6,25 +6,40 @@ class FollowService < BaseService
   # Follow a remote user, notify remote user about the follow
   # @param [Account] source_account From which to follow
   # @param [String, Account] uri User URI to follow in the form of username@domain (or account record)
-  def call(source_account, uri)
+  def call(source_account, uri, reblogs: nil)
+    reblogs = true if reblogs.nil?
     target_account = uri.is_a?(Account) ? uri : ResolveRemoteAccountService.new.call(uri)
 
     raise ActiveRecord::RecordNotFound if target_account.nil? || target_account.id == source_account.id || target_account.suspended?
     raise Mastodon::NotPermittedError  if target_account.blocking?(source_account) || source_account.blocking?(target_account)
 
-    return if source_account.following?(target_account) || source_account.requested?(target_account)
+    if source_account.following?(target_account)
+      # We're already following this account, but we'll call follow! again to
+      # make sure the reblogs status is set correctly.
+      source_account.follow!(target_account, reblogs: reblogs)
+      return
+    elsif source_account.requested?(target_account)
+      # This isn't managed by a method in AccountInteractions, so we modify it
+      # ourselves if necessary.
+      req = follow_requests.find_by(target_account: other_account)
+      if req.show_reblogs != reblogs
+        req.show_reblogs = reblogs
+        req.save!
+      end
+      return
+    end
 
     if target_account.locked? || target_account.activitypub?
-      request_follow(source_account, target_account)
+      request_follow(source_account, target_account, reblogs: reblogs)
     else
-      direct_follow(source_account, target_account)
+      direct_follow(source_account, target_account, reblogs: reblogs)
     end
   end
 
   private
 
-  def request_follow(source_account, target_account)
-    follow_request = FollowRequest.create!(account: source_account, target_account: target_account)
+  def request_follow(source_account, target_account, reblogs: true)
+    follow_request = FollowRequest.create!(account: source_account, target_account: target_account, reblogs: reblogs)
 
     if target_account.local?
       NotifyService.new.call(target_account, follow_request)
@@ -38,8 +53,8 @@ class FollowService < BaseService
     follow_request
   end
 
-  def direct_follow(source_account, target_account)
-    follow = source_account.follow!(target_account)
+  def direct_follow(source_account, target_account, reblogs: true)
+    follow = source_account.follow!(target_account, reblogs: reblogs)
 
     if target_account.local?
       NotifyService.new.call(target_account, follow)
diff --git a/db/schema.rb b/db/schema.rb
index f96a5340f..93505f9a0 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20171021191900) do
+ActiveRecord::Schema.define(version: 20171028221157) do
 
   # These are extensions that must be enabled in order to support this database
   enable_extension "plpgsql"
@@ -145,6 +145,7 @@ ActiveRecord::Schema.define(version: 20171021191900) do
     t.datetime "updated_at", null: false
     t.bigint "account_id", null: false
     t.bigint "target_account_id", null: false
+    t.boolean "show_reblogs", default: true, null: false
     t.index ["account_id", "target_account_id"], name: "index_follow_requests_on_account_id_and_target_account_id", unique: true
   end
 
@@ -153,6 +154,7 @@ ActiveRecord::Schema.define(version: 20171021191900) do
     t.datetime "updated_at", null: false
     t.bigint "account_id", null: false
     t.bigint "target_account_id", null: false
+    t.boolean "show_reblogs", default: true, null: false
     t.index ["account_id", "target_account_id"], name: "index_follows_on_account_id_and_target_account_id", unique: true
   end
 
-- 
cgit 


From b95c48748cd4e7a1181cdf3f17e23d6e526a9d95 Mon Sep 17 00:00:00 2001
From: aschmitz <aschmitz@lardbucket.org>
Date: Fri, 10 Nov 2017 20:11:10 -0600
Subject: Per-user reblog hiding implementation/fixes/tests

Note that this will only hide/show *future* reblogs by a user, and does
nothing to remove/add reblogs that are already in the timeline. I don't
think that's a particularly confusing behavior, and it's a lot easier
to implement (similar to mutes, I believe).
---
 app/models/concerns/account_interactions.rb        |  6 ++-
 app/models/follow_request.rb                       |  2 +-
 app/services/follow_service.rb                     |  2 +-
 app/services/notify_service.rb                     |  2 +-
 .../20171028221157_add_reblogs_to_follows.rb       | 21 ++++++++
 .../v1/accounts/relationships_controller_spec.rb   |  4 +-
 .../controllers/api/v1/accounts_controller_spec.rb |  8 +--
 spec/models/concerns/account_interactions_spec.rb  | 37 ++++++++++++++
 spec/models/follow_request_spec.rb                 | 24 ++++++++-
 spec/services/follow_service_spec.rb               | 58 ++++++++++++++++++++--
 spec/services/notify_service_spec.rb               | 20 ++++++++
 11 files changed, 170 insertions(+), 14 deletions(-)
 create mode 100644 db/migrate/20171028221157_add_reblogs_to_follows.rb

(limited to 'app/models')

diff --git a/app/models/concerns/account_interactions.rb b/app/models/concerns/account_interactions.rb
index 088fef4da..60fd6ded5 100644
--- a/app/models/concerns/account_interactions.rb
+++ b/app/models/concerns/account_interactions.rb
@@ -81,7 +81,7 @@ module AccountInteractions
       rel.show_reblogs = reblogs
       rel.save!
     end
-    
+
     rel
   end
 
@@ -156,6 +156,10 @@ module AccountInteractions
     mute_relationships.where(target_account: other_account, hide_notifications: true).exists?
   end
 
+  def muting_reblogs?(other_account)
+    active_relationships.where(target_account: other_account, show_reblogs: false).exists?
+  end
+
   def requested?(other_account)
     follow_requests.where(target_account: other_account).exists?
   end
diff --git a/app/models/follow_request.rb b/app/models/follow_request.rb
index 0608ffabc..1a1c52382 100644
--- a/app/models/follow_request.rb
+++ b/app/models/follow_request.rb
@@ -22,7 +22,7 @@ class FollowRequest < ApplicationRecord
   validates :account_id, uniqueness: { scope: :target_account_id }
 
   def authorize!
-    account.follow!(target_account, reblogs: reblogs)
+    account.follow!(target_account, reblogs: show_reblogs)
     MergeWorker.perform_async(target_account.id, account.id)
 
     destroy!
diff --git a/app/services/follow_service.rb b/app/services/follow_service.rb
index 70572110d..6db591999 100644
--- a/app/services/follow_service.rb
+++ b/app/services/follow_service.rb
@@ -39,7 +39,7 @@ class FollowService < BaseService
   private
 
   def request_follow(source_account, target_account, reblogs: true)
-    follow_request = FollowRequest.create!(account: source_account, target_account: target_account, reblogs: reblogs)
+    follow_request = FollowRequest.create!(account: source_account, target_account: target_account, show_reblogs: reblogs)
 
     if target_account.local?
       NotifyService.new.call(target_account, follow_request)
diff --git a/app/services/notify_service.rb b/app/services/notify_service.rb
index fb09df983..3fa3f152c 100644
--- a/app/services/notify_service.rb
+++ b/app/services/notify_service.rb
@@ -29,7 +29,7 @@ class NotifyService < BaseService
   end
 
   def blocked_reblog?
-    false
+    @recipient.muting_reblogs?(@notification.from_account)
   end
 
   def blocked_follow_request?
diff --git a/db/migrate/20171028221157_add_reblogs_to_follows.rb b/db/migrate/20171028221157_add_reblogs_to_follows.rb
new file mode 100644
index 000000000..eb4640a20
--- /dev/null
+++ b/db/migrate/20171028221157_add_reblogs_to_follows.rb
@@ -0,0 +1,21 @@
+require Rails.root.join('lib', 'mastodon', 'migration_helpers')
+
+class AddReblogsToFollows < ActiveRecord::Migration[5.1]
+  include Mastodon::MigrationHelpers
+
+  safety_assured do
+    disable_ddl_transaction!
+  end
+
+  def up
+    safety_assured do
+      add_column_with_default :follows, :show_reblogs, :boolean, default: true, allow_null: false
+      add_column_with_default :follow_requests, :show_reblogs, :boolean, default: true, allow_null: false
+    end
+  end
+  
+  def down
+    remove_column :follows, :show_reblogs
+    remove_column :follow_requests, :show_reblogs
+  end
+end
diff --git a/spec/controllers/api/v1/accounts/relationships_controller_spec.rb b/spec/controllers/api/v1/accounts/relationships_controller_spec.rb
index 431fc2194..f25b86ac1 100644
--- a/spec/controllers/api/v1/accounts/relationships_controller_spec.rb
+++ b/spec/controllers/api/v1/accounts/relationships_controller_spec.rb
@@ -32,7 +32,7 @@ describe Api::V1::Accounts::RelationshipsController do
         json = body_as_json
 
         expect(json).to be_a Enumerable
-        expect(json.first[:following]).to be true
+        expect(json.first[:following]).to be_truthy
         expect(json.first[:followed_by]).to be false
       end
     end
@@ -51,7 +51,7 @@ describe Api::V1::Accounts::RelationshipsController do
 
         expect(json).to be_a Enumerable
         expect(json.first[:id]).to eq simon.id.to_s
-        expect(json.first[:following]).to be true
+        expect(json.first[:following]).to be_truthy
         expect(json.first[:followed_by]).to be false
         expect(json.first[:muting]).to be false
         expect(json.first[:requested]).to be false
diff --git a/spec/controllers/api/v1/accounts_controller_spec.rb b/spec/controllers/api/v1/accounts_controller_spec.rb
index 053c53e5a..f3b879421 100644
--- a/spec/controllers/api/v1/accounts_controller_spec.rb
+++ b/spec/controllers/api/v1/accounts_controller_spec.rb
@@ -31,10 +31,10 @@ RSpec.describe Api::V1::AccountsController, type: :controller do
         expect(response).to have_http_status(:success)
       end
 
-      it 'returns JSON with following=true and requested=false' do
+      it 'returns JSON with following=truthy and requested=false' do
         json = body_as_json
 
-        expect(json[:following]).to be true
+        expect(json[:following]).to be_truthy
         expect(json[:requested]).to be false
       end
 
@@ -50,11 +50,11 @@ RSpec.describe Api::V1::AccountsController, type: :controller do
         expect(response).to have_http_status(:success)
       end
 
-      it 'returns JSON with following=false and requested=true' do
+      it 'returns JSON with following=false and requested=truthy' do
         json = body_as_json
 
         expect(json[:following]).to be false
-        expect(json[:requested]).to be true
+        expect(json[:requested]).to be_truthy
       end
 
       it 'creates a follow request relation between user and target user' do
diff --git a/spec/models/concerns/account_interactions_spec.rb b/spec/models/concerns/account_interactions_spec.rb
index ef957fc1d..f47d9d057 100644
--- a/spec/models/concerns/account_interactions_spec.rb
+++ b/spec/models/concerns/account_interactions_spec.rb
@@ -37,4 +37,41 @@ describe AccountInteractions do
       end
     end
   end
+
+  describe 'ignoring reblogs from an account' do
+    before do
+      @me = Fabricate(:account, username: 'Me')
+      @you = Fabricate(:account, username: 'You')
+    end
+
+    context 'with the reblogs option unspecified' do
+      before do
+        @me.follow!(@you)
+      end
+
+      it 'defaults to showing reblogs' do
+        expect(@me.muting_reblogs?(@you)).to be(false)
+      end
+    end
+
+    context 'with the reblogs option set to false' do
+      before do
+        @me.follow!(@you, reblogs: false)
+      end
+
+      it 'does mute reblogs' do
+        expect(@me.muting_reblogs?(@you)).to be(true)
+      end
+    end
+
+    context 'with the reblogs option set to true' do
+      before do
+        @me.follow!(@you, reblogs: true)
+      end
+
+      it 'does not mute reblogs' do
+        expect(@me.muting_reblogs?(@you)).to be(false)
+      end
+    end
+  end
 end
diff --git a/spec/models/follow_request_spec.rb b/spec/models/follow_request_spec.rb
index cc6f8ee62..62bd724d7 100644
--- a/spec/models/follow_request_spec.rb
+++ b/spec/models/follow_request_spec.rb
@@ -1,7 +1,29 @@
 require 'rails_helper'
 
 RSpec.describe FollowRequest, type: :model do
-  describe '#authorize!'
+  describe '#authorize!' do
+    it 'generates a Follow' do
+      follow_request = Fabricate.create(:follow_request)
+      follow_request.authorize!
+      target = follow_request.target_account
+      expect(follow_request.account.following?(target)).to be true
+    end
+
+    it 'correctly passes show_reblogs when true' do
+      follow_request = Fabricate.create(:follow_request, show_reblogs: true)
+      follow_request.authorize!
+      target = follow_request.target_account
+      expect(follow_request.account.muting_reblogs?(target)).to be false
+    end
+
+    it 'correctly passes show_reblogs when false' do
+      follow_request = Fabricate.create(:follow_request, show_reblogs: false)
+      follow_request.authorize!
+      target = follow_request.target_account
+      expect(follow_request.account.muting_reblogs?(target)).to be true
+    end
+  end
+
   describe '#reject!'
 
   describe 'validations' do
diff --git a/spec/services/follow_service_spec.rb b/spec/services/follow_service_spec.rb
index ceb39e5e6..e59a2f1a6 100644
--- a/spec/services/follow_service_spec.rb
+++ b/spec/services/follow_service_spec.rb
@@ -13,8 +13,20 @@ RSpec.describe FollowService do
         subject.call(sender, bob.acct)
       end
 
-      it 'creates a follow request' do
-        expect(FollowRequest.find_by(account: sender, target_account: bob)).to_not be_nil
+      it 'creates a follow request with reblogs' do
+        expect(FollowRequest.find_by(account: sender, target_account: bob, show_reblogs: true)).to_not be_nil
+      end
+    end
+
+    describe 'locked account, no reblogs' do
+      let(:bob) { Fabricate(:user, email: 'bob@example.com', account: Fabricate(:account, locked: true, username: 'bob')).account }
+
+      before do
+        subject.call(sender, bob.acct, reblogs: false)
+      end
+
+      it 'creates a follow request without reblogs' do
+        expect(FollowRequest.find_by(account: sender, target_account: bob, show_reblogs: false)).to_not be_nil
       end
     end
 
@@ -25,8 +37,22 @@ RSpec.describe FollowService do
         subject.call(sender, bob.acct)
       end
 
-      it 'creates a following relation' do
+      it 'creates a following relation with reblogs' do
+        expect(sender.following?(bob)).to be true
+        expect(sender.muting_reblogs?(bob)).to be false
+      end
+    end
+
+    describe 'unlocked account, no reblogs' do
+      let(:bob) { Fabricate(:user, email: 'bob@example.com', account: Fabricate(:account, username: 'bob')).account }
+
+      before do
+        subject.call(sender, bob.acct, reblogs: false)
+      end
+
+      it 'creates a following relation without reblogs' do
         expect(sender.following?(bob)).to be true
+        expect(sender.muting_reblogs?(bob)).to be true
       end
     end
 
@@ -42,6 +68,32 @@ RSpec.describe FollowService do
         expect(sender.following?(bob)).to be true
       end
     end
+
+    describe 'already followed account, turning reblogs off' do
+      let(:bob) { Fabricate(:user, email: 'bob@example.com', account: Fabricate(:account, username: 'bob')).account }
+
+      before do
+        sender.follow!(bob, reblogs: true)
+        subject.call(sender, bob.acct, reblogs: false)
+      end
+
+      it 'disables reblogs' do
+        expect(sender.muting_reblogs?(bob)).to be true
+      end
+    end
+
+    describe 'already followed account, turning reblogs on' do
+      let(:bob) { Fabricate(:user, email: 'bob@example.com', account: Fabricate(:account, username: 'bob')).account }
+
+      before do
+        sender.follow!(bob, reblogs: false)
+        subject.call(sender, bob.acct, reblogs: true)
+      end
+
+      it 'disables reblogs' do
+        expect(sender.muting_reblogs?(bob)).to be false
+      end
+    end
   end
 
   context 'remote OStatus account' do
diff --git a/spec/services/notify_service_spec.rb b/spec/services/notify_service_spec.rb
index 7088ae9d1..250a880a2 100644
--- a/spec/services/notify_service_spec.rb
+++ b/spec/services/notify_service_spec.rb
@@ -48,6 +48,26 @@ RSpec.describe NotifyService do
     is_expected.to_not change(Notification, :count)
   end
 
+  describe 'reblogs' do
+    let(:status)   { Fabricate(:status, account: Fabricate(:account)) }
+    let(:activity) { Fabricate(:status, account: sender, reblog: status) }
+
+    it 'shows reblogs by default' do
+      recipient.follow!(sender)
+      is_expected.to change(Notification, :count)
+    end
+
+    it 'shows reblogs when explicitly enabled' do
+      recipient.follow!(sender, reblogs: true)
+      is_expected.to change(Notification, :count)
+    end
+
+    it 'hides reblogs when disabled' do
+      recipient.follow!(sender, reblogs: false)
+      is_expected.to_not change(Notification, :count)
+    end
+  end
+
   context do
     let(:asshole)  { Fabricate(:account, username: 'asshole') }
     let(:reply_to) { Fabricate(:status, account: asshole) }
-- 
cgit 


From 5128c4261e8c067321e70ffda560f14036f56bb0 Mon Sep 17 00:00:00 2001
From: aschmitz <aschmitz@lardbucket.org>
Date: Sat, 11 Nov 2017 14:37:23 -0600
Subject: Updates per code review

Thanks, @valerauko!
---
 app/controllers/api/v1/accounts_controller.rb | 2 +-
 app/models/concerns/account_interactions.rb   | 5 +----
 app/services/follow_service.rb                | 6 ++----
 3 files changed, 4 insertions(+), 9 deletions(-)

(limited to 'app/models')

diff --git a/app/controllers/api/v1/accounts_controller.rb b/app/controllers/api/v1/accounts_controller.rb
index afdbf6e2d..85eb2d60e 100644
--- a/app/controllers/api/v1/accounts_controller.rb
+++ b/app/controllers/api/v1/accounts_controller.rb
@@ -17,7 +17,7 @@ class Api::V1::AccountsController < Api::BaseController
     
     FollowService.new.call(current_user.account, @account.acct, reblogs_arg)
 
-    options = @account.locked? ? {} : { following_map: reblogs_arg, requested_map: { @account.id => false } }
+    options = @account.locked? ? {} : { following_map: { @account.id => reblogs_arg }, requested_map: { @account.id => false } }
 
     render json: @account, serializer: REST::RelationshipSerializer, relationships: relationships(options)
   end
diff --git a/app/models/concerns/account_interactions.rb b/app/models/concerns/account_interactions.rb
index 60fd6ded5..a68f7c3d8 100644
--- a/app/models/concerns/account_interactions.rb
+++ b/app/models/concerns/account_interactions.rb
@@ -77,10 +77,7 @@ module AccountInteractions
   def follow!(other_account, reblogs: nil)
     reblogs = true if reblogs.nil?
     rel = active_relationships.create_with(show_reblogs: reblogs).find_or_create_by!(target_account: other_account)
-    if rel.show_reblogs != reblogs
-      rel.show_reblogs = reblogs
-      rel.save!
-    end
+    rel.update!(show_reblogs: reblogs)
 
     rel
   end
diff --git a/app/services/follow_service.rb b/app/services/follow_service.rb
index 6db591999..20579ca63 100644
--- a/app/services/follow_service.rb
+++ b/app/services/follow_service.rb
@@ -6,6 +6,7 @@ class FollowService < BaseService
   # Follow a remote user, notify remote user about the follow
   # @param [Account] source_account From which to follow
   # @param [String, Account] uri User URI to follow in the form of username@domain (or account record)
+  # @param [true, false, nil] reblogs Whether or not to show reblogs, defaults to true
   def call(source_account, uri, reblogs: nil)
     reblogs = true if reblogs.nil?
     target_account = uri.is_a?(Account) ? uri : ResolveRemoteAccountService.new.call(uri)
@@ -22,10 +23,7 @@ class FollowService < BaseService
       # This isn't managed by a method in AccountInteractions, so we modify it
       # ourselves if necessary.
       req = follow_requests.find_by(target_account: other_account)
-      if req.show_reblogs != reblogs
-        req.show_reblogs = reblogs
-        req.save!
-      end
+      req.update!(show_reblogs: reblogs)
       return
     end
 
-- 
cgit 


From 656d54e9451dc99e212513b799a4deb4d1227bf0 Mon Sep 17 00:00:00 2001
From: David Yip <yipdw@member.fsf.org>
Date: Mon, 13 Nov 2017 11:06:02 -0600
Subject: Maintain case-insensitivity when merging multiple matchers (#213)

When given two regexps, Regexp.union preserves the options set (or not
set) on each regex; this meant that none of the multiline (m),
case-insensitivity (i), or extended syntax (x) options were set.  Our
regexps are written expecting the m, i, and x options were set on all of
them, so we need to make sure that we preserve that behavior.
---
 app/models/glitch/keyword_mute.rb       | 4 ++--
 spec/models/glitch/keyword_mute_spec.rb | 7 +++++++
 2 files changed, 9 insertions(+), 2 deletions(-)

(limited to 'app/models')

diff --git a/app/models/glitch/keyword_mute.rb b/app/models/glitch/keyword_mute.rb
index 73de4d4b7..009de1880 100644
--- a/app/models/glitch/keyword_mute.rb
+++ b/app/models/glitch/keyword_mute.rb
@@ -35,7 +35,7 @@ class Glitch::KeywordMute < ApplicationRecord
     def initialize(account_id)
       @account_id = account_id
       regex_text = Rails.cache.fetch("keyword_mutes:regex:#{account_id}") { regex_text_for_account }
-      @regex = /#{regex_text}/i
+      @regex = /#{regex_text}/
     end
 
     def =~(str)
@@ -60,7 +60,7 @@ class Glitch::KeywordMute < ApplicationRecord
       sb = keyword =~ /\A[[:word:]]/ ? '\b' : ''
       eb = keyword =~ /[[:word:]]\Z/ ? '\b' : ''
 
-      /#{sb}#{Regexp.escape(keyword)}#{eb}/
+      /(?mix:#{sb}#{Regexp.escape(keyword)}#{eb})/
     end
   end
 end
diff --git a/spec/models/glitch/keyword_mute_spec.rb b/spec/models/glitch/keyword_mute_spec.rb
index 1423823ba..9685c6493 100644
--- a/spec/models/glitch/keyword_mute_spec.rb
+++ b/spec/models/glitch/keyword_mute_spec.rb
@@ -60,6 +60,13 @@ RSpec.describe Glitch::KeywordMute, type: :model do
         expect(matcher =~ 'This is a HOT take').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 =~ 'This is a HOT take').to be_truthy
+      end
+
       it 'matches keywords surrounded by non-alphanumeric ornamentation' do
         Glitch::KeywordMute.create!(account: alice, keyword: 'hot')
 
-- 
cgit