solr-ruby 0.0.6 → 0.0.7

data/lib/solr/request/custom.rb

@@ -0,0 +1,50 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'erb'
+
+# "Abstract" base class, only useful with subclasses that add parameters
+class Solr::Request::Custom < Solr::Request::Select
+      
+  def initialize(qt=nil, params={}, content_type='application/x-www-form-urlencoded; charset=utf-8')
+    super(qt,params)
+    @content_type = content_type
+  end
+  
+  def handler
+    @query_type.starts_with('/') ? qt.remove_first('/') : 'select'
+  end
+  
+  def content_type
+    @content_type
+  end
+
+  def to_hash
+    return {:qt => query_type, :wt => 'ruby'}.merge(@select_params)
+  end
+  
+  def to_s
+    raw_params = self.to_hash
+
+    http_params = []
+    raw_params.each do |key,value|
+      if value.respond_to? :each
+        value.each { |v| http_params << "#{key}=#{ERB::Util::url_encode(v)}" unless v.nil?}
+      else
+        http_params << "#{key}=#{ERB::Util::url_encode(value)}" unless value.nil?
+      end
+    end
+
+    http_params.join("&")
+  end
+  
+end

data/lib/solr/request/select.rb

@@ -43,7 +43,7 @@ class Solr::Request::Select < Solr::Request::Base
 
     http_params = []
     raw_params.each do |key,value|
-      if value.respond_to? :each
+      if value.respond_to?(:each) && !value.is_a?(String)
         value.each { |v| http_params << "#{key}=#{ERB::Util::url_encode(v)}" unless v.nil?}
       else
         http_params << "#{key}=#{ERB::Util::url_encode(value)}" unless value.nil?

data/lib/solr/request/standard.rb

@@ -75,6 +75,7 @@ class Solr::Request::Standard < Solr::Request::Select
       hash["facet.mincount"] = @params[:facets][:mincount]
       hash["facet.prefix"] = @params[:facets][:prefix]
       hash["facet.offset"] = @params[:facets][:offset]
+      hash["facet.method"] = @params[:facets][:method] if @params[:facets][:method]
       if @params[:facets][:fields]  # facet fields are optional (could be facet.query only)
         @params[:facets][:fields].each do |f|
           if f.kind_of? Hash
@@ -95,25 +96,263 @@ class Solr::Request::Standard < Solr::Request::Select
     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
-      if @params[:highlighting][:max_alternate_field_length]
-        @params[:highlighting][:max_alternate_field_length].each do |k,v|
-          hash["f.#{k}.hl.maxAlternateFieldLength"] = v
+
+      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
+
+      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]

data/test/unit/standard_request_test.rb

@@ -103,27 +103,197 @@ class StandardRequestTest < Test::Unit::TestCase
     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

metadata

@@ -1,33 +1,26 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: solr-ruby
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
-date: 2008-07-14 00:00:00 -04:00
-summary: Ruby library for working with Apache Solr
-require_paths: 
-- lib
-email: ruby-dev@lucene.apache.org
-homepage: http://wiki.apache.org/solr/solr-ruby
-rubyforge_project: 
-description: 
-autorequire: solr
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 0.0.7
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Apache Solr
+autorequire: solr
+bindir: bin
+cert_chain: []
+
+date: 2009-03-05 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: ruby-dev@lucene.apache.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
 files: 
 - lib/solr
 - lib/solr/connection.rb
@@ -47,6 +40,7 @@ files:
 - lib/solr/request/add_document.rb
 - lib/solr/request/base.rb
 - lib/solr/request/commit.rb
+- lib/solr/request/custom.rb
 - lib/solr/request/delete.rb
 - lib/solr/request/dismax.rb
 - lib/solr/request/index_info.rb
@@ -107,17 +101,31 @@ files:
 - test/unit/util_test.rb
 - test/unit/xpath_mapper_test.rb
 - test/unit/xpath_test_file.xml
-test_files: []
-
+has_rdoc: true
+homepage: http://wiki.apache.org/solr/solr-ruby
+post_install_message: 
 rdoc_options: []
 
-extra_rdoc_files: []
-
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
+rubyforge_project: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Ruby library for working with Apache Solr
+test_files: []