Merge remote-tracking branch 'origin/main' into feature/206

backend/app/controllers/posts_controller.rb

@@ -245,41 +245,19 @@ class PostsController < ApplicationController
   end
 
   def filter_posts_by_tags tag_names, match_type
-    literals = tag_names.map do |raw_name|
-      { name: TagName.canonicalise(raw_name.sub(/\Anot:/i, '')).first,
-        negative: raw_name.downcase.start_with?('not:') }
-    end
+    tag_names = TagName.canonicalise(tag_names)
 
-    return Post.all if literals.empty?
+    posts = Post.joins(tags: :tag_name)
 
     if match_type == 'any'
-      literals.reduce(Post.none) do |posts, literal|
-        posts.or(tag_literal_relation(literal[:name], negative: literal[:negative]))
-      end
+      posts.where(tag_names: { name: tag_names }).distinct
     else
-      literals.reduce(Post.all) do |posts, literal|
-        ids = tagged_post_ids_for(literal[:name])
-        if literal[:negative]
-          posts.where.not(id: ids)
-        else
-          posts.where(id: ids)
-        end
-      end
+      posts.where(tag_names: { name: tag_names })
+           .group('posts.id')
+           .having('COUNT(DISTINCT tag_names.id) = ?', tag_names.uniq.size)
     end
   end
 
-  def tag_literal_relation name, negative:
-    ids = tagged_post_ids_for(name)
-    if negative
-      Post.where.not(id: ids)
-    else
-      Post.where(id: ids)
-    end
-  end
-
-  def tagged_post_ids_for(name) =
-      Post.joins(tags: :tag_name).where(tag_names: { name: }).select(:id)
-
   def sync_post_tags! post, desired_tags
     desired_tags.each do |t|
       t.save! if t.new_record?

backend/app/controllers/tags_controller.rb

@@ -17,7 +17,8 @@ class TagsController < ApplicationController
   end
 
   def autocomplete
-    q = params[:q].to_s.strip.sub(/\Anot:/i, '')
+    q = params[:q].to_s.strip
+    return render json: [] if q.blank?
 
     with_nico = bool?(:nico, default: true)
     present_only = bool?(:present, default: true)

backend/app/models/tag.rb

@@ -152,22 +152,17 @@ class Tag < ApplicationRecord
         st.post_tags.find_each do |pt|
           if PostTag.kept.exists?(post_id: pt.post_id, tag_id: target_tag.id)
             pt.discard_by!(nil)
+            # discard 後の update! は禁止なので DB を直に更新
+            pt.update_columns(tag_id: target_tag.id, updated_at: Time.current)
+          else
+            pt.update!(tag: target_tag)
           end
-          # discard 後の update! は禁止なので DB を直に更新
-          pt.update_columns(tag_id: target_tag.id, updated_at: Time.current)
         end
 
         tag_name = st.tag_name
-        nico_flg = st.nico?
         st.destroy!
         tag_name.reload
-
-        if nico_flg
-          tag_name.destroy!
-        else
-          tag_name.update_columns(canonical_id: target_tag.tag_name&.id,
-                                  updated_at: Time.current)
-        end
+        tag_name.update!(canonical: target_tag.tag_name)
       end
 
       # 投稿件数を再集計

backend/app/models/tag_name.rb

@@ -10,7 +10,6 @@ class TagName < ApplicationRecord
   validate :canonical_must_be_canonical
   validate :alias_name_must_not_have_prefix
   validate :canonical_must_not_be_present_with_tag_or_wiki_page
-  validate :name_must_be_sanitised
 
   def self.canonicalise names
     names = Array(names).map { |n| n.to_s.strip }.reject(&:blank?)
@@ -23,10 +22,6 @@ class TagName < ApplicationRecord
 
   private
 
-  def sanitise_name
-    self.name = TagNameSanitisationRule.sanitise(name)
-  end
-
   def canonical_must_be_canonical
     if canonical&.canonical_id?
       errors.add :canonical, 'canonical は実体を示す必要があります．'
@@ -44,10 +39,4 @@ class TagName < ApplicationRecord
       errors.add :canonical, 'タグもしくは Wiki の参照がある名前はエーリアスになれません．'
     end
   end
-
-  def name_must_be_sanitised
-    if name != TagNameSanitisationRule.sanitise(name)
-      errors.add :name, '名前に使用できない文字が含まれてゐます．'
-    end
-  end
 end

backend/app/models/tag_name_sanitisation_rule.rb

@@ -1,55 +0,0 @@
-class TagNameSanitisationRule < ApplicationRecord
-  include Discard::Model
-
-  self.primary_key = :priority
-
-  default_scope -> { kept }
-
-  validates :source_pattern, presence: true, uniqueness: true
-
-  validate :source_pattern_must_be_regexp
-
-  class << self
-    def sanitise(name) =
-        rules.reduce(name.dup) { |name, (pattern, replacement)| name.gsub(pattern, replacement) }
-
-    def apply!
-      TagName.find_each do |tn|
-        name = sanitise(tn.name)
-        next if name == tn.name
-
-        TagName.transaction do
-          existing_tn = TagName.find_by(name:)
-          if existing_tn
-            existing_tn = existing_tn.canonical || existing_tn
-            next if existing_tn.id == tn.id
-
-            if existing_tn.tag
-              Tag.merge_tags!(existing_tn.tag, tn.tag) if tn.tag
-            elsif tn.tag
-              tn.tag.update_columns(tag_name_id: existing_tn.id, updated_at: Time.current)
-            end
-            tn.destroy!
-
-            next
-          end
-
-          # TagName 側の自動サニタイズを回避
-          tn.update_columns(name:, updated_at: Time.current)
-        end
-      end
-    end
-
-    private
-
-    def rules = kept.order(:priority).map { |r| [Regexp.new(r.source_pattern), r.replacement] }
-  end
-
-  private
-
-  def source_pattern_must_be_regexp
-    Regexp.new(source_pattern)
-  rescue RegexpError
-    errors.add :source_pattern, '変な正規表現だね〜（笑）'
-  end
-end

backend/db/migrate/20260309123200_create_tag_name_sanitisation_rules.rb

@@ -1,31 +0,0 @@
-class CreateTagNameSanitisationRules < ActiveRecord::Migration[8.0]
-  def up
-    create_table :tag_name_sanitisation_rules, id: :integer, primary_key: :priority do |t|
-      t.string :source_pattern, null: false
-      t.string :replacement, null: false
-      t.timestamps
-      t.datetime :discarded_at
-      t.index :source_pattern, unique: true
-      t.index :discarded_at
-    end
-
-    now = ActiveRecord::Base.connection.quote(Time.current)
-    execute <<~SQL
-      INSERT INTO
-        tag_name_sanitisation_rules(priority, source_pattern, replacement, created_at, updated_at)
-      VALUES
-        (10, '\\\\*',           '_',         #{ now }, #{ now })
-      , (20, '\\\\?',           '_',         #{ now }, #{ now })
-      , (25, '\\\\/',           '_',         #{ now }, #{ now })
-      , (30, '_+',              '_',         #{ now }, #{ now })
-      , (40, '_$',              '',          #{ now }, #{ now })
-      , (45, '^([^:]+\\\\:)?_', '\\\\1',     #{ now }, #{ now })
-      , (50, '^([^:]+\\\\:)?$', '\\\\1null', #{ now }, #{ now })
-      ;
-    SQL
-  end
-
-  def down
-    drop_table :tag_name_sanitisation_rules
-  end
-end

backend/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[8.0].define(version: 2026_03_09_123200) do
+ActiveRecord::Schema[8.0].define(version: 2026_03_03_122700) do
   create_table "active_storage_attachments", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.string "name", null: false
     t.string "record_type", null: false
@@ -127,16 +127,6 @@ ActiveRecord::Schema[8.0].define(version: 2026_03_09_123200) do
     t.index ["tag_id"], name: "index_tag_implications_on_tag_id"
   end
 
-  create_table "tag_name_sanitisation_rules", primary_key: "priority", id: :integer, charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
-    t.string "source_pattern", null: false
-    t.string "replacement", null: false
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.datetime "discarded_at"
-    t.index ["discarded_at"], name: "index_tag_name_sanitisation_rules_on_discarded_at"
-    t.index ["source_pattern"], name: "index_tag_name_sanitisation_rules_on_source_pattern", unique: true
-  end
-
   create_table "tag_names", charset: "utf8mb4", collation: "utf8mb4_0900_ai_ci", force: :cascade do |t|
     t.string "name", null: false
     t.bigint "canonical_id"

backend/lib/tasks/sync_nico.rake

@@ -108,7 +108,7 @@ namespace :nico do
       desired_non_nico_tag_ids = []
 
       datum['tags'].each do |raw|
-        name = TagNameSanitisationRule.sanitise("nico:#{ raw }")
+        name = "nico:#{ raw }"
         tag = Tag.find_or_create_by_tag_name!(name, category: :nico)
         desired_nico_tag_based_ids << tag.id
 

backend/spec/factories/tags.rb

@@ -1,22 +1,12 @@
 FactoryBot.define do
   factory :tag do
-    transient do
-      name { nil }
-    end
-
     category { :general }
     post_count { 0 }
     association :tag_name
 
-    after(:build) do |tag, evaluator|
-      tag.name = evaluator.name if evaluator.name.present?
-    end
-
     trait :nico do
       category { :nico }
-      transient do
-        name { "nico:#{ SecureRandom.hex(4) }" }
-      end
+      tag_name { association(:tag_name, name: "nico:#{ SecureRandom.hex(4) }") }
     end
   end
 end

backend/spec/models/tag_name_sanitisation_rule_spec.rb

@@ -1,100 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe TagNameSanitisationRule, type: :model do
-  describe '.sanitise' do
-    before do
-      described_class.create!(priority: 10, source_pattern: '_', replacement: '')
-      described_class.create!(priority: 20, source_pattern: 'ABC', replacement: 'abc')
-    end
-
-    it 'applies sanitisation rules sequentially in priority order' do
-      expect(described_class.sanitise('A_B_C')).to eq('abc')
-    end
-
-    it 'does not fail when a rule does not match' do
-      expect { described_class.sanitise('xyz') }.not_to raise_error
-      expect(described_class.sanitise('xyz')).to eq('xyz')
-    end
-  end
-
-  describe 'validations' do
-    it 'is invalid when source_pattern is not a valid regexp' do
-      rule = described_class.new(priority: 10, source_pattern: '[', replacement: '')
-      expect(rule).to be_invalid
-      expect(rule.errors[:source_pattern]).to be_present
-    end
-  end
-
-  describe '.apply!' do
-    before do
-      described_class.create!(priority: 10, source_pattern: '_', replacement: '')
-    end
-
-    context 'when no conflicting tag_name exists' do
-      let!(:tag_name) do
-        TagName.create!(name: 'tmp').tap do |tn|
-          tn.update_columns(name: 'foo_bar', updated_at: Time.current)
-        end
-      end
-
-      it 'renames the tag_name' do
-        described_class.apply!
-        expect(tag_name.reload.name).to eq('foobar')
-      end
-    end
-
-    context 'when a conflicting canonical tag_name exists' do
-      let!(:existing) { TagName.create!(name: 'foobar') }
-      let!(:source) do
-        TagName.create!(name: 'tmp').tap do |tn|
-          tn.update_columns(name: 'foo_bar', updated_at: Time.current)
-        end
-      end
-
-      it 'deletes the source tag_name' do
-        described_class.apply!
-        expect(TagName.exists?(source.id)).to be(false)
-        expect(existing.reload.name).to eq('foobar')
-      end
-    end
-
-    context 'when the source tag_name has a tag and the existing one has no tag' do
-      let!(:existing) { TagName.create!(name: 'foobar') }
-      let!(:source_tag) { create(:tag, name: 'tmp', category: :general) }
-      let!(:source_tag_name_id) { source_tag.tag_name_id }
-
-      before do
-        source_tag.tag_name.update_columns(name: 'foo_bar', updated_at: Time.current)
-      end
-
-      it 'moves the tag to the existing tag_name' do
-        described_class.apply!
-        expect(source_tag.reload.tag_name_id).to eq(existing.id)
-        expect(TagName.exists?(source_tag_name_id)).to be(false)
-      end
-    end
-
-    context 'when both source and existing tag_names have tags' do
-      let!(:existing_tn) { TagName.create!(name: 'foobar') }
-      let!(:existing_tag) { Tag.create!(tag_name: existing_tn, category: :general) }
-
-      let!(:source_tn) { TagName.create!(name: 'tmp') }
-      let!(:source_tag) { Tag.create!(tag_name: source_tn, category: :general) }
-      let!(:source_tag_name_id) { source_tn.id }
-
-      before do
-        source_tn.update_columns(name: 'foo_bar', updated_at: Time.current)
-      end
-
-      it 'merges the source tag into the existing tag and deletes the source tag_name' do
-        expect(TagName.find_by(name: 'foobar')&.tag&.id).to eq(existing_tag.id)
-        expect(TagName.find_by(name: 'foo_bar')&.tag&.id).to eq(source_tag.id)
-
-        described_class.apply!
-
-        expect(Tag.exists?(source_tag.id)).to be(false)
-        expect(TagName.exists?(source_tag.tag_name_id)).to be(false)
-      end
-    end
-  end
-end

backend/spec/models/tag_spec.rb

@@ -2,13 +2,10 @@ require 'rails_helper'
 
 RSpec.describe Tag, type: :model do
   describe '.merge_tags!' do
-    let!(:target_tag) { create(:tag, category: :general) }
-    let!(:source_tag) { create(:tag, category: :general) }
-    let!(:source_tag_name) { source_tag.tag_name }
+    let!(:target_tag) { create(:tag) }
+    let!(:source_tag) { create(:tag) }
 
-    let!(:post_record) do
-      Post.create!(url: 'https://example.com/posts/1', title: 'test post')
-    end
+    let!(:post_record) { Post.create!(url: 'https://example.com/posts/1', title: 'test post') }
 
     context 'when merging a simple source tag' do
       let!(:source_post_tag) { PostTag.create!(post: post_record, tag: source_tag) }
@@ -18,8 +15,7 @@ RSpec.describe Tag, type: :model do
 
         expect(source_post_tag.reload.tag_id).to eq(target_tag.id)
         expect(Tag.exists?(source_tag.id)).to be(false)
-        expect(source_tag_name.reload.canonical_id).to eq(target_tag.tag_name_id)
-        expect(target_tag.reload.post_count).to eq(1)
+        expect(source_tag.tag_name.reload.canonical_id).to eq(target_tag.tag_name_id)
       end
     end
 
@@ -35,10 +31,8 @@ RSpec.describe Tag, type: :model do
 
         expect(active.count).to eq(1)
         expect(discarded_source.discarded_at).to be_present
-        expect(discarded_source.tag_id).to eq(target_tag.id)
         expect(Tag.exists?(source_tag.id)).to be(false)
-        expect(source_tag_name.reload.canonical_id).to eq(target_tag.tag_name_id)
-        expect(target_tag.reload.post_count).to eq(1)
+        expect(source_tag.tag_name.reload.canonical_id).to eq(target_tag.tag_name_id)
       end
     end
 
@@ -51,41 +45,26 @@ RSpec.describe Tag, type: :model do
         expect(Tag.exists?(target_tag.id)).to be(true)
         expect(Tag.exists?(source_tag.id)).to be(false)
         expect(source_post_tag.reload.tag_id).to eq(target_tag.id)
-        expect(target_tag.reload.post_count).to eq(1)
       end
     end
 
-    context 'when aliasing the source tag_name would be invalid under normal validation' do
+    context 'when aliasing the source tag_name is invalid' do
       let!(:source_post_tag) { PostTag.create!(post: post_record, tag: source_tag) }
       let!(:wiki_page) do
         WikiPage.create!(
-          tag_name: source_tag_name,
-          created_user: create_admin_user!,
-          updated_user: create_admin_user!
-        )
+            tag_name: source_tag.tag_name,
+            created_user: create_admin_user!,
+            updated_user: create_admin_user!)
       end
 
-      it 'still merges by bypassing validations' do
-        described_class.merge_tags!(target_tag, [source_tag])
+      it 'rolls back the transaction' do
+        expect {
+          described_class.merge_tags!(target_tag, [source_tag])
+        }.to raise_error(ActiveRecord::RecordInvalid)
 
-        expect(Tag.exists?(source_tag.id)).to be(false)
-        expect(source_post_tag.reload.tag_id).to eq(target_tag.id)
-        expect(source_tag_name.reload.canonical_id).to eq(target_tag.tag_name_id)
-        expect(source_tag_name.reload).not_to be_valid
-      end
-    end
-
-    context 'when merging a nico source tag' do
-      let!(:target_tag) { create(:tag, category: :nico, name: 'nico:foo') }
-      let!(:source_tag) { create(:tag, category: :nico, name: 'nico:bar') }
-      let!(:source_tag_name_id) { source_tag.tag_name_id }
-
-      it 'deletes the source tag_name instead of aliasing it' do
-        described_class.merge_tags!(target_tag, [source_tag])
-
-        expect(Tag.exists?(source_tag.id)).to be(false)
-        expect(TagName.exists?(source_tag_name_id)).to be(false)
-        expect(target_tag.reload.post_count).to eq(0)
+        expect(Tag.exists?(source_tag.id)).to be(true)
+        expect(source_post_tag.reload.tag_id).to eq(source_tag.id)
+        expect(source_tag.tag_name.reload.canonical_id).to be_nil
       end
     end
   end

backend/spec/requests/posts_spec.rb

@@ -16,7 +16,7 @@ RSpec.describe 'Posts API', type: :request do
   end
 
   let!(:tag_name) { TagName.create!(name: 'spec_tag') }
-  let!(:tag)      { Tag.create!(tag_name: tag_name, category: :general) }
+  let!(:tag)      { Tag.create!(tag_name: tag_name, category: 'general') }
 
   let!(:post_record) do
     Post.create!(title: 'spec post', url: 'https://example.com/spec').tap do |p|
@@ -28,9 +28,9 @@ RSpec.describe 'Posts API', type: :request do
     let!(:user) { create_member_user! }
 
     let!(:tag_name) { TagName.create!(name: "spec_tag") }
-    let!(:tag) { Tag.create!(tag_name:, category: :general) }
+    let!(:tag) { Tag.create!(tag_name:, category: "general") }
     let!(:tag_name2) { TagName.create!(name: 'unko') }
-    let!(:tag2) { Tag.create!(tag_name: tag_name2, category: :deerjikist) }
+    let!(:tag2) { Tag.create!(tag_name: tag_name2, category: 'deerjikist') }
     let!(:alias_tag_name) { TagName.create!(name: 'manko', canonical: tag_name) }
 
     let!(:hit_post) do
@@ -116,123 +116,6 @@ RSpec.describe 'Posts API', type: :request do
       end
     end
 
-    context 'when tags contain not:' do
-      let!(:foo_tag_name) { TagName.create!(name: 'not_spec_foo') }
-      let!(:foo_tag) { Tag.create!(tag_name: foo_tag_name, category: :general) }
-
-      let!(:bar_tag_name) { TagName.create!(name: 'not_spec_bar') }
-      let!(:bar_tag) { Tag.create!(tag_name: bar_tag_name, category: :general) }
-
-      let!(:baz_tag_name) { TagName.create!(name: 'not_spec_baz') }
-      let!(:baz_tag) { Tag.create!(tag_name: baz_tag_name, category: :general) }
-
-      let!(:foo_alias_tag_name) do
-        TagName.create!(name: 'not_spec_foo_alias', canonical: foo_tag_name)
-      end
-
-      let!(:foo_only_post) do
-        Post.create!(uploaded_user: user, title: 'foo only',
-                     url: 'https://example.com/not-spec-foo').tap do |p|
-          PostTag.create!(post: p, tag: foo_tag)
-        end
-      end
-
-      let!(:bar_only_post) do
-        Post.create!(uploaded_user: user, title: 'bar only',
-                     url: 'https://example.com/not-spec-bar').tap do |p|
-          PostTag.create!(post: p, tag: bar_tag)
-        end
-      end
-
-      let!(:baz_only_post) do
-        Post.create!(uploaded_user: user, title: 'baz only',
-                     url: 'https://example.com/not-spec-baz').tap do |p|
-          PostTag.create!(post: p, tag: baz_tag)
-        end
-      end
-
-      let!(:foo_bar_post) do
-        Post.create!(uploaded_user: user, title: 'foo bar',
-                     url: 'https://example.com/not-spec-foo-bar').tap do |p|
-          PostTag.create!(post: p, tag: foo_tag)
-          PostTag.create!(post: p, tag: bar_tag)
-        end
-      end
-
-      let!(:foo_baz_post) do
-        Post.create!(uploaded_user: user, title: 'foo baz',
-                     url: 'https://example.com/not-spec-foo-baz').tap do |p|
-          PostTag.create!(post: p, tag: foo_tag)
-          PostTag.create!(post: p, tag: baz_tag)
-        end
-      end
-
-      let(:controlled_ids) do
-        [foo_only_post.id, bar_only_post.id, baz_only_post.id,
-         foo_bar_post.id, foo_baz_post.id]
-      end
-
-      it 'supports not search' do
-        get '/posts', params: { tags: 'not:not_spec_foo' }
-
-        expect(response).to have_http_status(:ok)
-
-        expect(json.fetch('posts').map { |p| p['id'] } & controlled_ids).to match_array(
-          [bar_only_post.id, baz_only_post.id]
-        )
-      end
-
-      it 'supports alias in not search' do
-        get '/posts', params: { tags: 'not:not_spec_foo_alias' }
-
-        expect(response).to have_http_status(:ok)
-
-        expect(json.fetch('posts').map { |p| p['id'] } & controlled_ids).to match_array(
-          [bar_only_post.id, baz_only_post.id]
-        )
-      end
-
-      it 'treats multiple not terms as AND when match is omitted' do
-        get '/posts', params: { tags: 'not:not_spec_foo not:not_spec_bar' }
-
-        expect(response).to have_http_status(:ok)
-
-        expect(json.fetch('posts').map { |p| p['id'] } & controlled_ids).to match_array(
-          [baz_only_post.id]
-        )
-      end
-
-      it 'treats multiple not terms as OR when match=any' do
-        get '/posts', params: { tags: 'not:not_spec_foo not:not_spec_bar', match: 'any' }
-
-        expect(response).to have_http_status(:ok)
-
-        expect(json.fetch('posts').map { |p| p['id'] } & controlled_ids).to match_array(
-          [foo_only_post.id, bar_only_post.id, baz_only_post.id, foo_baz_post.id]
-        )
-      end
-
-      it 'supports mixed positive and negative search with AND' do
-        get '/posts', params: { tags: 'not_spec_foo not:not_spec_bar' }
-
-        expect(response).to have_http_status(:ok)
-
-        expect(json.fetch('posts').map { |p| p['id'] } & controlled_ids).to match_array(
-          [foo_only_post.id, foo_baz_post.id]
-        )
-      end
-
-      it 'supports mixed positive and negative search with OR when match=any' do
-        get '/posts', params: { tags: 'not_spec_foo not:not_spec_bar', match: 'any' }
-
-        expect(response).to have_http_status(:ok)
-
-        expect(json.fetch('posts').map { |p| p['id'] } & controlled_ids).to match_array(
-          [foo_only_post.id, baz_only_post.id, foo_bar_post.id, foo_baz_post.id]
-        )
-      end
-    end
-
     context 'when url is provided' do
       let!(:url_hit_post) do
         Post.create!(uploaded_user: user, title: 'url hit',
@@ -526,7 +409,7 @@ RSpec.describe 'Posts API', type: :request do
     context "when nico tag already exists in tags" do
       before do
         Tag.find_or_create_by!(tag_name: TagName.find_or_create_by!(name: 'nico:nico_tag'),
-                               category: :nico)
+                               category: 'nico')
       end
 
       it 'return 400' do
@@ -592,7 +475,7 @@ RSpec.describe 'Posts API', type: :request do
 
       # 追加で別タグも作って、更新時に入れ替わることを見る
       tn2 = TagName.create!(name: 'spec_tag_2')
-      Tag.create!(tag_name: tn2, category: :general)
+      Tag.create!(tag_name: tn2, category: 'general')
 
       put "/posts/#{post_record.id}", params: {
         title: 'updated title',
@@ -611,7 +494,7 @@ RSpec.describe 'Posts API', type: :request do
     context "when nico tag already exists in tags" do
       before do
         Tag.find_or_create_by!(tag_name: TagName.find_or_create_by!(name: 'nico:nico_tag'),
-                               category: :nico)
+                               category: 'nico')
       end
 
       it 'return 400' do
@@ -648,7 +531,7 @@ RSpec.describe 'Posts API', type: :request do
     it 'returns add/remove events (history) for a post' do
       # add
       tn2 = TagName.create!(name: 'spec_tag2')
-      tag2 = Tag.create!(tag_name: tn2, category: :general)
+      tag2 = Tag.create!(tag_name: tn2, category: 'general')
       pt = PostTag.create!(post: post_record, tag: tag2, created_user: member)
 
       # remove (discard)

frontend/src/components/TagSearch.tsx

@@ -56,11 +56,8 @@ export default (() => {
       if (activeIndex < 0)
 	break
       ev.preventDefault ()
-      {
-	const selected = suggestions[activeIndex]
-	if (selected)
-	  handleTagSelect (selected)
-      }
+      const selected = suggestions[activeIndex]
+      selected && handleTagSelect (selected)
       break
 
     case 'Escape':
@@ -70,25 +67,14 @@ export default (() => {
     }
     if (ev.key === 'Enter' && (!(suggestionsVsbl) || activeIndex < 0))
       {
-	const parts = search.split (' ')
-	const match = parts.map (t => t.toLowerCase ()).includes ('type:or') ? 'any' : 'all'
-	navigate (`/posts?${
-	    (new URLSearchParams ({
-		tags: parts.map (t => t.toLowerCase ())
-			   .filter (t => t !== 'type:or')
-			   .join (' '),
-		match }))
-	    .toString () }`)
+	navigate (`/posts?${ (new URLSearchParams ({ tags: search })).toString () }`)
 	setSuggestionsVsbl (false)
       }
   }
 
   const handleTagSelect = (tag: Tag) => {
     const parts = search.split (' ')
-    parts[parts.length - 1] = (
-	(parts[parts.length - 1].slice(0, 4).toLowerCase () === 'not:')
-	? ('not:' + tag.name)
-	: tag.name)
+    parts[parts.length - 1] = tag.name
     setSearch (parts.join (' ') + ' ')
     setSuggestions ([])
     setActiveIndex (-1)
@@ -96,8 +82,7 @@ export default (() => {
 
   useEffect (() => {
     const query = new URLSearchParams (location.search)
-    const anyFlg = query.get ('match') === 'any'
-    const tagsQuery = `${ query.get ('tags') ?? '' }${ anyFlg ? ' type:or' : '' }`
+    const tagsQuery = query.get ('tags') ?? ''
     setSearch (tagsQuery)
   }, [location.search])