You are viewing a plain text version of this content. The canonical link for it is here.
Posted to solr-commits@lucene.apache.org by ko...@apache.org on 2008/07/31 18:21:07 UTC
svn commit: r681409 - in /lucene/solr/trunk/client/ruby/solr-ruby:
lib/solr/request/standard.rb test/unit/standard_request_test.rb
Author: koji
Date: Thu Jul 31 09:21:05 2008
New Revision: 681409
URL: http://svn.apache.org/viewvc?rev=681409&view=rev
Log:
SOLR-662: solr-ruby now supports all highlighter parameters.
Modified:
lucene/solr/trunk/client/ruby/solr-ruby/lib/solr/request/standard.rb
lucene/solr/trunk/client/ruby/solr-ruby/test/unit/standard_request_test.rb
Modified: lucene/solr/trunk/client/ruby/solr-ruby/lib/solr/request/standard.rb
URL: http://svn.apache.org/viewvc/lucene/solr/trunk/client/ruby/solr-ruby/lib/solr/request/standard.rb?rev=681409&r1=681408&r2=681409&view=diff
==============================================================================
--- lucene/solr/trunk/client/ruby/solr-ruby/lib/solr/request/standard.rb (original)
+++ lucene/solr/trunk/client/ruby/solr-ruby/lib/solr/request/standard.rb Thu Jul 31 09:21:05 2008
@@ -95,25 +95,263 @@
end
# highlighting parameter processing - http://wiki.apache.org/solr/HighlightingParameters
- #TODO need to add per-field overriding to snippets, fragsize, requiredFieldMatch, formatting, and simple.pre/post
if @params[:highlighting]
hash[:hl] = true
hash["hl.fl"] = @params[:highlighting][:field_list].join(',') if @params[:highlighting][:field_list]
- hash["hl.snippets"] = @params[:highlighting][:max_snippets]
- hash["hl.requireFieldMatch"] = @params[:highlighting][:require_field_match]
- hash["hl.simple.pre"] = @params[:highlighting][:prefix]
- hash["hl.simple.post"] = @params[:highlighting][:suffix]
- hash["hl.fragsize"] = @params[:highlighting][:fragment_size]
- if @params[:highlighting][:alternate_fields]
- @params[:highlighting][:alternate_fields].each do |k,v|
- hash["f.#{k}.hl.alternateField"] = v
+
+ snippets = @params[:highlighting][:max_snippets]
+ if snippets
+ if snippets.kind_of? Hash
+ if snippets[:default]
+ hash["hl.snippets"] = snippets[:default]
+ end
+ if snippets[:fields]
+ snippets[:fields].each do |k,v|
+ hash["f.#{k}.hl.snippets"] = v
+ end
+ end
+ else
+ hash["hl.snippets"] = snippets
+ end
+ end
+
+ fragsize = @params[:highlighting][:fragment_size]
+ if fragsize
+ if fragsize.kind_of? Hash
+ if fragsize[:default]
+ hash["hl.fragsize"] = fragsize[:default]
+ end
+ if fragsize[:fields]
+ fragsize[:fields].each do |k,v|
+ hash["f.#{k}.hl.fragsize"] = v
+ end
+ end
+ else
+ hash["hl.fragsize"] = fragsize
+ end
+ end
+
+ rfm = @params[:highlighting][:require_field_match]
+ if nil != rfm
+ if rfm.kind_of? Hash
+ if nil != rfm[:default]
+ hash["hl.requireFieldMatch"] = rfm[:default]
+ end
+ if rfm[:fields]
+ rfm[:fields].each do |k,v|
+ hash["f.#{k}.hl.requireFieldMatch"] = v
+ end
+ end
+ else
+ hash["hl.requireFieldMatch"] = rfm
+ end
+ end
+
+ mac = @params[:highlighting][:max_analyzed_chars]
+ if mac
+ if mac.kind_of? Hash
+ if mac[:default]
+ hash["hl.maxAnalyzedChars"] = mac[:default]
+ end
+ if mac[:fields]
+ mac[:fields].each do |k,v|
+ hash["f.#{k}.hl.maxAnalyzedChars"] = v
+ end
+ end
+ else
+ hash["hl.maxAnalyzedChars"] = mac
+ end
+ end
+
+ prefix = @params[:highlighting][:prefix]
+ if prefix
+ if prefix.kind_of? Hash
+ if prefix[:default]
+ hash["hl.simple.pre"] = prefix[:default]
+ end
+ if prefix[:fields]
+ prefix[:fields].each do |k,v|
+ hash["f.#{k}.hl.simple.pre"] = v
+ end
+ end
+ else
+ hash["hl.simple.pre"] = prefix
+ end
+ end
+
+ suffix = @params[:highlighting][:suffix]
+ if suffix
+ if suffix.kind_of? Hash
+ if suffix[:default]
+ hash["hl.simple.post"] = suffix[:default]
+ end
+ if suffix[:fields]
+ suffix[:fields].each do |k,v|
+ hash["f.#{k}.hl.simple.post"] = v
+ end
+ end
+ else
+ hash["hl.simple.post"] = suffix
+ end
+ end
+
+ formatter = @params[:highlighting][:formatter]
+ if formatter
+ if formatter.kind_of? Hash
+ if formatter[:default]
+ hash["hl.formatter"] = formatter[:default]
+ end
+ if formatter[:fields]
+ formatter[:fields].each do |k,v|
+ hash["f.#{k}.hl.formatter"] = v
+ end
+ end
+ else
+ hash["hl.formatter"] = formatter
+ end
+ end
+
+ fragmenter = @params[:highlighting][:fragmenter]
+ if fragmenter
+ if fragmenter.kind_of? Hash
+ if fragmenter[:default]
+ hash["hl.fragmenter"] = fragmenter[:default]
+ end
+ if fragmenter[:fields]
+ fragmenter[:fields].each do |k,v|
+ hash["f.#{k}.hl.fragmenter"] = v
+ end
+ end
+ else
+ hash["hl.fragmenter"] = fragmenter
+ end
+ end
+
+ merge_contiguous = @params[:highlighting][:merge_contiguous]
+ if nil != merge_contiguous
+ if merge_contiguous.kind_of? Hash
+ if nil != merge_contiguous[:default]
+ hash["hl.mergeContiguous"] = merge_contiguous[:default]
+ end
+ if merge_contiguous[:fields]
+ merge_contiguous[:fields].each do |k,v|
+ hash["f.#{k}.hl.mergeContiguous"] = v
+ end
+ end
+ else
+ hash["hl.mergeContiguous"] = merge_contiguous
end
end
- if @params[:highlighting][:max_alternate_field_length]
- @params[:highlighting][:max_alternate_field_length].each do |k,v|
- hash["f.#{k}.hl.maxAlternateFieldLength"] = v
+
+ increment = @params[:highlighting][:increment]
+ if increment
+ if increment.kind_of? Hash
+ if increment[:default]
+ hash["hl.increment"] = increment[:default]
+ end
+ if increment[:fields]
+ increment[:fields].each do |k,v|
+ hash["f.#{k}.hl.increment"] = v
+ end
+ end
+ else
+ hash["hl.increment"] = increment
+ end
+ end
+
+ # support "old style"
+ alternate_fields = @params[:highlighting][:alternate_fields]
+ if alternate_fields
+ alternate_fields.each do |f,v|
+ hash["f.#{f}.hl.alternateField"] = v
+ end
+ end
+
+ alternate_field = @params[:highlighting][:alternate_field]
+ if alternate_field
+ if alternate_field.kind_of? Hash
+ if alternate_field[:default]
+ hash["hl.alternateField"] = alternate_field[:default]
+ end
+ if alternate_field[:fields]
+ alternate_field[:fields].each do |k,v|
+ hash["f.#{k}.hl.alternateField"] = v
+ end
+ end
+ else
+ hash["hl.alternateField"] = alternate_field
end
end
+
+ mafl = @params[:highlighting][:max_alternate_field_length]
+ if mafl
+ if mafl.kind_of? Hash
+ if mafl[:default]
+ hash["hl.maxAlternateFieldLength"] = mafl[:default]
+ end
+ if mafl[:fields]
+ mafl[:fields].each do |k,v|
+ hash["f.#{k}.hl.maxAlternateFieldLength"] = v
+ end
+ else
+ # support "old style"
+ mafl.each do |k,v|
+ hash["f.#{k}.hl.maxAlternateFieldLength"] = v
+ end
+ end
+ else
+ hash["hl.maxAlternateFieldLength"] = mafl
+ end
+ end
+
+ hash["hl.usePhraseHighlighter"] = @params[:highlighting][:use_phrase_highlighter]
+
+ regex = @params[:highlighting][:regex]
+ if regex
+ if regex[:slop]
+ if regex[:slop].kind_of? Hash
+ if regex[:slop][:default]
+ hash["hl.regex.slop"] = regex[:slop][:default]
+ end
+ if regex[:slop][:fields]
+ regex[:slop][:fields].each do |k,v|
+ hash["f.#{k}.hl.regex.slop"] = v
+ end
+ end
+ else
+ hash["hl.regex.slop"] = regex[:slop]
+ end
+ end
+ if regex[:pattern]
+ if regex[:pattern].kind_of? Hash
+ if regex[:pattern][:default]
+ hash["hl.regex.pattern"] = regex[:pattern][:default]
+ end
+ if regex[:pattern][:fields]
+ regex[:pattern][:fields].each do |k,v|
+ hash["f.#{k}.hl.regex.pattern"] = v
+ end
+ end
+ else
+ hash["hl.regex.pattern"] = regex[:pattern]
+ end
+ end
+ if regex[:max_analyzed_chars]
+ if regex[:max_analyzed_chars].kind_of? Hash
+ if regex[:max_analyzed_chars][:default]
+ hash["hl.regex.maxAnalyzedChars"] = regex[:max_analyzed_chars][:default]
+ end
+ if regex[:max_analyzed_chars][:fields]
+ regex[:max_analyzed_chars][:fields].each do |k,v|
+ hash["f.#{k}.hl.regex.maxAnalyzedChars"] = v
+ end
+ end
+ else
+ hash["hl.regex.maxAnalyzedChars"] = regex[:max_analyzed_chars]
+ end
+ end
+ end
+
end
if @params[:mlt]
Modified: lucene/solr/trunk/client/ruby/solr-ruby/test/unit/standard_request_test.rb
URL: http://svn.apache.org/viewvc/lucene/solr/trunk/client/ruby/solr-ruby/test/unit/standard_request_test.rb?rev=681409&r1=681408&r2=681409&view=diff
==============================================================================
--- lucene/solr/trunk/client/ruby/solr-ruby/test/unit/standard_request_test.rb (original)
+++ lucene/solr/trunk/client/ruby/solr-ruby/test/unit/standard_request_test.rb Thu Jul 31 09:21:05 2008
@@ -103,27 +103,197 @@
request = Solr::Request::Standard.new(:query => 'query',
:highlighting => {
:field_list => ['title', 'author'],
- :alternate_fields => {'title'=>'title', 'author'=>'author'},
- :max_alternate_field_length => {'title'=>30, 'author'=>20},
+ :merge_contiguous => true,
+ :increment => 100,
:max_snippets => 3,
:require_field_match => true,
:prefix => "<blink>",
:suffix => "</blink>",
- :fragment_size => 300
+ :fragment_size => 300,
+ :max_analyzed_chars => 102400,
+ :formatter => 'myFormatter',
+ :fragmenter => 'myFragmenter',
+ :use_phrase_highlighter => true
}
)
hash = request.to_hash
assert_equal true, hash[:hl]
assert_equal "title,author", hash["hl.fl"]
- assert_equal "title", hash["f.title.hl.alternateField"]
- assert_equal "author", hash["f.author.hl.alternateField"]
- assert_equal 30, hash["f.title.hl.maxAlternateFieldLength"]
- assert_equal 20, hash["f.author.hl.maxAlternateFieldLength"]
+ assert_equal true, hash["hl.mergeContiguous"]
+ assert_equal 100, hash["hl.increment"]
+ assert_equal 3, hash["hl.snippets"]
assert_equal true, hash["hl.requireFieldMatch"]
assert_equal "<blink>", hash["hl.simple.pre"]
assert_equal "</blink>", hash["hl.simple.post"]
assert_equal 300, hash["hl.fragsize"]
+ assert_equal 102400, hash["hl.maxAnalyzedChars"]
+ assert_equal "myFormatter", hash["hl.formatter"]
+ assert_equal "myFragmenter", hash["hl.fragmenter"]
+ assert_equal true, hash["hl.usePhraseHighlighter"]
+ end
+
+ def test_highlighting2
+ request = Solr::Request::Standard.new(:query => 'query',
+ :highlighting => {
+ :field_list => ['title', 'author'],
+ :merge_contiguous => {
+ :default=>false, :fields=>{'author'=>true}
+ },
+ :increment => {
+ :default=>100, :fields=>{'author'=>200}
+ },
+ :max_snippets => {
+ :default=>2,:fields=>{'author'=>3}
+ },
+ :prefix => {
+ :default=>"<em>", :fields=>{'author'=>"<blink>"},
+ },
+ :suffix => {
+ :default=>"</em>", :fields=>{'author'=>"</blink>"},
+ },
+ :fragment_size => {
+ :default=>300,:fields=>{'author'=>200}
+ },
+ :max_analyzed_chars => {
+ :default=>102400,:fields=>{'author'=>51200}
+ },
+ :require_field_match => {
+ :default=>false, :fields=>{'author'=>true}
+ },
+ :formatter => {
+ :default=>'defaultFormatter', :fields=>{'title'=>'titleFormatter'}
+ },
+ :fragmenter => {
+ :default=>'defaultFragmenter',:fields=>{'title'=>'titleFragmenter'}
+ },
+ }
+ )
+
+ hash = request.to_hash
+ assert_equal true, hash[:hl]
+ assert_equal "title,author", hash["hl.fl"]
+ assert_equal false, hash["hl.mergeContiguous"]
+ assert_equal true, hash["f.author.hl.mergeContiguous"]
+ assert_equal 100, hash["hl.increment"]
+ assert_equal 200, hash["f.author.hl.increment"]
+ assert_equal 2, hash["hl.snippets"]
+ assert_equal 3, hash["f.author.hl.snippets"]
+ assert_equal "<em>", hash["hl.simple.pre"]
+ assert_equal "<blink>", hash["f.author.hl.simple.pre"]
+ assert_equal "</em>", hash["hl.simple.post"]
+ assert_equal "</blink>", hash["f.author.hl.simple.post"]
+ assert_equal 300, hash["hl.fragsize"]
+ assert_equal 200, hash["f.author.hl.fragsize"]
+ assert_equal 102400, hash["hl.maxAnalyzedChars"]
+ assert_equal 51200, hash["f.author.hl.maxAnalyzedChars"]
+ assert_equal false, hash["hl.requireFieldMatch"]
+ assert_equal true, hash["f.author.hl.requireFieldMatch"]
+ assert_equal 'defaultFormatter', hash["hl.formatter"]
+ assert_equal 'titleFormatter', hash["f.title.hl.formatter"]
+ assert_equal 'defaultFragmenter', hash["hl.fragmenter"]
+ assert_equal 'titleFragmenter', hash["f.title.hl.fragmenter"]
+ end
+
+ def test_highlighting_regex
+ request = Solr::Request::Standard.new(:query => 'query',
+ :highlighting => {
+ :field_list => ['title', 'author'],
+ :regex => {
+ :slop => 0.8,
+ :pattern => '\w',
+ :max_analyzed_chars => 10000
+ }
+ }
+ )
+
+ hash = request.to_hash
+ assert_equal true, hash[:hl]
+ assert_equal "title,author", hash["hl.fl"]
+ assert_equal 0.8, hash["hl.regex.slop"]
+ assert_equal '\w', hash["hl.regex.pattern"]
+ assert_equal 10000, hash["hl.regex.maxAnalyzedChars"]
+ end
+
+ def test_highlighting_regex2
+ request = Solr::Request::Standard.new(:query => 'query',
+ :highlighting => {
+ :field_list => ['title', 'author'],
+ :regex => {
+ :slop => { :default=>0.5, :fields=>{'author'=>0.8} },
+ :pattern => { :default=>'\w', :fields=>{'author'=>'\n'} },
+ :max_analyzed_chars => { :default=>10000, :fields=>{'author'=>20000} }
+ }
+ }
+ )
+
+ hash = request.to_hash
+ assert_equal true, hash[:hl]
+ assert_equal "title,author", hash["hl.fl"]
+ assert_equal 0.5, hash["hl.regex.slop"]
+ assert_equal 0.8, hash["f.author.hl.regex.slop"]
+ assert_equal '\w', hash["hl.regex.pattern"]
+ assert_equal '\n', hash["f.author.hl.regex.pattern"]
+ assert_equal 10000, hash["hl.regex.maxAnalyzedChars"]
+ assert_equal 20000, hash["f.author.hl.regex.maxAnalyzedChars"]
+ end
+
+ def test_highlighting_alternate_field
+ request = Solr::Request::Standard.new(:query => 'query',
+ :highlighting => {
+ :field_list => ['title', 'author'],
+ :alternate_field => 'title',
+ :max_alternate_field_length => 30
+ }
+ )
+
+ hash = request.to_hash
+ assert_equal true, hash[:hl]
+ assert_equal "title,author", hash["hl.fl"]
+ assert_equal "title", hash["hl.alternateField"]
+ assert_equal 30, hash["hl.maxAlternateFieldLength"]
+ end
+
+ def test_highlighting_alternate_field2
+ request = Solr::Request::Standard.new(:query => 'query',
+ :highlighting => {
+ :field_list => ['title', 'author'],
+ :alternate_field => {
+ :default=>'default', :fields=>{'title'=>'title', 'author'=>'author'}
+ },
+ :max_alternate_field_length => {
+ :default=>10, :fields=>{'title'=>30, 'author'=>20}
+ }
+ }
+ )
+
+ hash = request.to_hash
+ assert_equal true, hash[:hl]
+ assert_equal "title,author", hash["hl.fl"]
+ assert_equal "default", hash["hl.alternateField"]
+ assert_equal "title", hash["f.title.hl.alternateField"]
+ assert_equal "author", hash["f.author.hl.alternateField"]
+ assert_equal 10, hash["hl.maxAlternateFieldLength"]
+ assert_equal 30, hash["f.title.hl.maxAlternateFieldLength"]
+ assert_equal 20, hash["f.author.hl.maxAlternateFieldLength"]
+ end
+
+ def test_highlighting_alternate_field_old_style
+ request = Solr::Request::Standard.new(:query => 'query',
+ :highlighting => {
+ :field_list => ['title', 'author'],
+ :alternate_fields => {'title'=>'title', 'author'=>'author'},
+ :max_alternate_field_length => {'title'=>30, 'author'=>20}
+ }
+ )
+
+ hash = request.to_hash
+ assert_equal true, hash[:hl]
+ assert_equal "title,author", hash["hl.fl"]
+ assert_equal "title", hash["f.title.hl.alternateField"]
+ assert_equal "author", hash["f.author.hl.alternateField"]
+ assert_equal 30, hash["f.title.hl.maxAlternateFieldLength"]
+ assert_equal 20, hash["f.author.hl.maxAlternateFieldLength"]
end
def test_mlt