Redmine

  # Renders the warnings about the filters of the given query

  def render_query_filter_warnings(query)

    safe_join(query.filter_warnings.map {|warning| content_tag('p', warning, :class => 'warning')})

  end

  # Filter types and operators whose value is split into tokens

  # by Redmine::Search::Tokenizer

  TOKENIZED_FILTER_TYPES = [:string, :text, :search].freeze

  TOKENIZED_FILTER_OPERATORS = ["~", "*~", "!~", "^", "$"].freeze

  # Returns warning messages about filters that are applied only partially.

  # Unlike errors, warnings do not prevent the query from being run

  def filter_warnings

    return [] unless filters

    filters.keys.filter_map do |field|

      next unless TOKENIZED_FILTER_TYPES.include?(type_for(field)) &&

                    TOKENIZED_FILTER_OPERATORS.include?(operator_for(field))

      tokenizer = Redmine::Search::Tokenizer.new(values_for(field)&.first)

      next unless tokenizer.truncated?

      connector = l(:'support.array.words_connector')

      tokens = tokenizer.tokens.map {|token| %("#{token}")}.join(connector)

      message = l(:notice_search_tokens_truncated,

                  :max => Redmine::Search::Tokenizer::MAX_TOKENS,

                  :tokens => tokens.truncate(100, :separator => connector))

      "#{label_for(field)}: #{message}"

    end

  end

<%= render_query_filter_warnings @query %>

<%= render_query_filter_warnings @query %>

<%= render_query_filter_warnings @query %>

  notice_search_tokens_truncated: "A maximum of %{max} search terms can be used. Only the following terms were used: %{tokens}"

      # Maximum number of tokens to search for

      MAX_TOKENS = 5

      # Returns the tokens to search for (no more than MAX_TOKENS)

        all_tokens.first(MAX_TOKENS)

      end

      # Returns true if some tokens are ignored because the question

      # contains more than MAX_TOKENS tokens

      def truncated?

        all_tokens.size > MAX_TOKENS

      end

      private

      def all_tokens

        @all_tokens ||= begin

          # extract tokens from the question

          # eg. hello "bye bye" => ["hello", "bye bye"]

          tokens = @question.scan(/"[^"]+"|[^\p{Zs}]+/).map do |token|

            # Remove quotes from quoted tokens, strip surrounding whitespace

            # e.g. "\" foo bar \"" => "foo bar"

            token.gsub(/\A"\p{Zs}*|\p{Zs}*"\Z/, '')

          end

          # tokens must be at least 2 characters long

          # but for Chinese characters (Chinese HANZI/Japanese KANJI), tokens can be one character

          tokens.uniq.select{|w| w.length > 1 || w =~ /\p{Han}/}

  def test_index_with_too_many_tokens_in_filter_should_display_warning_and_results

    get(

      :index,

      :params => {

        :project_id => 1,

        :set_filter => 1,

        :f => ['subject'],

        :op => {'subject' => '*~'},

        :v => {'subject' => ['one two print <script>alert(1)</script> three four']}

      }

    )

    assert_response :success

    assert_select '#errorExplanation', 0

    assert_select 'p.warning', :count => 1,

                  :text => 'Subject: A maximum of 5 search terms can be used. Only the following terms were used: ' \

                           '"one", "two", "print", "<script>alert(1)</script>", "three"'

    assert_not_include '<script>alert(1)</script>', response.body

    # Issues are still displayed using the first 5 tokens

    assert_select 'table.issues tr.issue'

  end

  def test_tokenize_should_return_no_more_than_max_tokens

    tokenizer = Redmine::Search::Tokenizer.new('one two three four five six seven')

    assert_equal %w[one two three four five], tokenizer.tokens

    assert tokenizer.truncated?

    assert_not Redmine::Search::Tokenizer.new('one two three four five').truncated?

  end

  def test_filter_warnings_should_include_used_tokens

    query = IssueQuery.new(

      :name => '_',

      :filters => {

        'subject' => {:operator => '*~', :values => ['one two three four five six seven']},

        'description' => {:operator => '~', :values => ['one two three four five']},

        'any_searchable' => {:operator => '!~', :values => ['a one "two three" one four five six seven']}

      }

    )

    assert query.valid?

    assert_equal(

      [

        'Subject: A maximum of 5 search terms can be used. Only the following terms were used: "one", "two", "three", "four", "five"',

        'Any searchable text: A maximum of 5 search terms can be used. Only the following terms were used: "one", "two three", "four", "five", "six"'

      ],

      query.filter_warnings

    )

  end

  def test_filter_warnings_should_ignore_operators_and_filters_that_do_not_tokenize_the_value

    query = IssueQuery.new(

      :name => '_',

      :filters => {

        'subject' => {:operator => '*', :values => ['']},

        'status_id' => {:operator => 'o', :values => ['']},

        'parent_id' => {:operator => '~', :values => ['1,2,3,4,5,6,7']}

      }

    )

    assert_equal [], query.filter_warnings

    user_query = UserQuery.new(

      :name => '_',

      :filters => {'login' => {:operator => '=', :values => ['one two three four five six']}}

    )

    assert_equal [], user_query.filter_warnings

  end