honkster-acts_as_solr 0.1.0

data/lib/solr/request/base.rb

@@ -0,0 +1,36 @@
+# 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.
+
+class Solr::Request::Base
+  
+  
+  #TODO : Add base support for the debugQuery flag, and such that the response provides debug output easily
+
+  # returns either :xml or :ruby depending on what the
+  # response type is for a given request
+  
+  def response_format
+    raise "unknown request type: #{self.class}"
+  end
+  
+  def content_type
+    'text/xml; charset=utf-8'
+  end
+
+  # returns the solr handler or url fragment that can 
+  # respond to this type of request
+  
+  def handler
+    raise "unknown request type: #{self.class}"
+  end
+
+end

data/lib/solr/request/commit.rb

@@ -0,0 +1,29 @@
+# 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.
+
+class Solr::Request::Commit < Solr::Request::Update
+
+  def initialize(options={})
+    @wait_searcher = options[:wait_searcher] || true
+    @wait_flush = options[:wait_flush] || true
+  end
+
+
+  def to_s
+    e = Solr::XML::Element.new('commit')
+    e.attributes['waitSearcher'] = @wait_searcher ? 'true' : 'false'
+    e.attributes['waitFlush'] = @wait_flush ? 'true' : 'false'
+    
+    e.to_s
+  end
+
+end

data/lib/solr/request/delete.rb

@@ -0,0 +1,48 @@
+# 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.
+
+class Solr::Request::Delete < Solr::Request::Update
+
+  # A delete request can be for a specific document id
+  #
+  #   request = Solr::Request::Delete.new(:id => 1234)
+  #
+  # or by query:
+  #
+  #   request = Solr::Request::Delete.new(:query =>
+  #
+  def initialize(options)
+    unless options.kind_of?(Hash) and (options[:id] or options[:query])
+      raise Solr::Exception.new("must pass in :id or :query")
+    end
+    if options[:id] and options[:query]
+      raise Solr::Exception.new("can't pass in both :id and :query")
+    end
+    @document_id = options[:id]
+    @query = options[:query]
+  end
+
+  def to_s
+    delete_element = Solr::XML::Element.new('delete')
+    if @document_id
+      id_element = Solr::XML::Element.new('id')
+      id_element.text = @document_id
+      delete_element.add_element(id_element)
+    elsif @query
+      query = Solr::XML::Element.new('query')
+      query.text = @query 
+      delete_element.add_element(query)
+    end
+    delete_element.to_s
+  end
+end
+

data/lib/solr/request/dismax.rb

@@ -0,0 +1,46 @@
+# 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.
+
+class Solr::Request::Dismax < Solr::Request::Standard
+
+  VALID_PARAMS.replace(VALID_PARAMS + [:tie_breaker, :query_fields, :minimum_match, :phrase_fields, :phrase_slop,
+                                       :boost_query, :boost_functions])
+
+  def initialize(params)
+    @alternate_query = params.delete(:alternate_query)
+    @sort_values = params.delete(:sort)
+    
+    super
+    
+    @query_type = "dismax"
+  end
+  
+  def to_hash
+    hash = super
+    hash[:tie] = @params[:tie_breaker]
+    hash[:mm]  = @params[:minimum_match]
+    hash[:qf]  = @params[:query_fields]
+    hash[:pf]  = @params[:phrase_fields]
+    hash[:ps]  = @params[:phrase_slop]
+    hash[:bq]  = @params[:boost_query]
+    hash[:bf]  = @params[:boost_functions]
+    hash["q.alt"] = @alternate_query
+    # FIXME: 2007-02-13 <coda.hale@gmail.com> --  This code is duplicated in
+    # Solr::Request::Standard. It should be refactored into a single location.
+    hash[:sort] = @sort_values.collect do |sort|
+      key = sort.keys[0]
+      "#{key.to_s} #{sort[key] == :descending ? 'desc' : 'asc'}"
+    end.join(',') if @sort_values
+    return hash
+  end
+
+end

data/lib/solr/request/index_info.rb

@@ -0,0 +1,22 @@
+# 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.
+
+class Solr::Request::IndexInfo < Solr::Request::Select
+  
+  def handler
+    'admin/luke'
+  end
+  
+  def to_hash
+    {:numTerms => 0}.merge(super.to_hash)
+  end
+end

data/lib/solr/request/modify_document.rb

@@ -0,0 +1,46 @@
+# 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.
+
+class Solr::Request::ModifyDocument < Solr::Request::Update
+
+  # Example: ModifyDocument.new(:id => 10, :overwrite => {:field_name => "new value"})
+  def initialize(update_data)
+    modes = []
+    @doc = {}
+    [:overwrite, :append, :distinct, :increment, :delete].each do |mode|
+      field_data = update_data[mode]
+      if field_data
+        field_data.each do |field_name, field_value|
+          modes << "#{field_name}:#{mode.to_s.upcase}"
+          @doc[field_name] = field_value if field_value  # if value is nil, omit so it can be removed
+        end
+        update_data.delete mode
+      end
+    end
+    @mode = modes.join(",")
+    
+    # only one key should be left over, the id
+    @doc[update_data.keys[0].to_s] = update_data.values[0]
+  end
+
+  # returns the request as a string suitable for posting
+  def to_s
+    e = Solr::XML::Element.new 'add'
+    e.add_element(Solr::Document.new(@doc).to_xml)
+    return e.to_s
+  end
+  
+  def handler
+    "update?mode=#{@mode}"
+  end
+  
+end

data/lib/solr/request/optimize.rb

@@ -0,0 +1,19 @@
+# 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.
+
+class Solr::Request::Optimize < Solr::Request::Update
+
+  def to_s
+    Solr::XML::Element.new('optimize').to_s
+  end
+
+end

data/lib/solr/request/ping.rb

@@ -0,0 +1,36 @@
+# 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.
+
+# TODO: Consider something lazy like this?
+# Solr::Request::Ping = Solr::Request.simple_request :format=>:xml, :handler=>'admin/ping'
+# class Solr::Request
+#   def self.simple_request(options)
+#     Class.new do 
+#       def response_format
+#         options[:format]
+#       end
+#       def handler
+#         options[:handler]
+#       end
+#     end
+#   end
+# end
+
+class Solr::Request::Ping < Solr::Request::Base
+  def response_format
+    :xml
+  end
+  
+  def handler
+    'admin/ping'
+  end
+end

data/lib/solr/request/select.rb

@@ -0,0 +1,54 @@
+# 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.
+
+# "Abstract" base class, only useful with subclasses that add parameters
+class Solr::Request::Select < Solr::Request::Base
+      
+  attr_reader :query_type
+  
+  def initialize(qt=nil, params={})
+    @query_type = qt
+    @select_params = params
+  end
+  
+  def response_format
+    :ruby
+  end
+  
+  def handler
+    'select'
+  end
+  
+  def content_type
+    'application/x-www-form-urlencoded; charset=utf-8'
+  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/spellcheck.rb

@@ -0,0 +1,30 @@
+# 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.
+
+class Solr::Request::Spellcheck < Solr::Request::Select
+
+  def initialize(params)
+    super('spellchecker')
+    @params = params
+  end
+  
+  def to_hash
+    hash = super
+    hash[:q] = @params[:query]
+    hash[:suggestionCount] = @params[:suggestion_count]
+    hash[:accuracy] = @params[:accuracy]
+    hash[:onlyMorePopular] = @params[:only_more_popular]
+    hash[:cmd] = @params[:command]
+    return hash
+  end
+
+end

data/lib/solr/request/standard.rb

@@ -0,0 +1,402 @@
+# 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.
+
+class Solr::Request::Standard < Solr::Request::Select
+
+  VALID_PARAMS = [:query, :sort, :default_field, :operator, :start, :rows, :shards, :date_facets,
+    :filter_queries, :field_list, :debug_query, :explain_other, :facets, :highlighting, :mlt]
+  
+  def initialize(params)
+    super('standard')
+    
+    raise "Invalid parameters: #{(params.keys - VALID_PARAMS).join(',')}" unless 
+      (params.keys - VALID_PARAMS).empty?
+    
+    raise ":query parameter required" unless params[:query]
+    
+    @params = params.dup
+    
+    # Validate operator
+    if params[:operator]
+      raise "Only :and/:or operators allowed" unless 
+        [:and, :or].include?(params[:operator])
+        
+      @params[:operator] = params[:operator].to_s.upcase
+    end
+
+    # Validate start, rows can be transformed to ints
+    @params[:start] = params[:start].to_i if params[:start]
+    @params[:rows] = params[:rows].to_i if params[:rows]
+    
+    @params[:field_list] ||= ["*","score"]
+    
+    @params[:shards] ||= []
+  end
+  
+  def to_hash
+    hash = {}
+    
+    # standard request param processing
+    sort = @params[:sort].collect do |sort|
+      key = sort.keys[0]
+      "#{key.to_s} #{sort[key] == :descending ? 'desc' : 'asc'}"
+    end.join(',') if @params[:sort]
+    hash[:q] = sort ? "#{@params[:query]};#{sort}" : @params[:query]
+    hash["q.op"] = @params[:operator]
+    hash[:df] = @params[:default_field]
+
+    # common parameter processing
+    hash[:start] = @params[:start]
+    hash[:rows] = @params[:rows]
+    hash[:fq] = @params[:filter_queries]
+    hash[:fl] = @params[:field_list].join(',')
+    hash[:debugQuery] = @params[:debug_query]
+    hash[:explainOther] = @params[:explain_other]
+    hash[:shards] = @params[:shards].join(',') unless @params[:shards].empty?
+    
+    # facet parameter processing
+    if @params[:facets]
+      # TODO need validation of all that is under the :facets Hash too
+      hash[:facet] = true
+      hash["facet.field"] = []
+      hash["facet.query"] = @params[:facets][:queries]
+      hash["facet.sort"] = (@params[:facets][:sort] == :count) if @params[:facets][:sort]
+      hash["facet.limit"] = @params[:facets][:limit]
+      hash["facet.missing"] = @params[:facets][:missing]
+      hash["facet.mincount"] = @params[:facets][:mincount]
+      hash["facet.prefix"] = @params[:facets][:prefix]
+      hash["facet.offset"] = @params[:facets][:offset]
+      if @params[:facets][:fields]  # facet fields are optional (could be facet.query only)
+        @params[:facets][:fields].each do |f|
+          if f.kind_of? Hash
+            key = f.keys[0]
+            value = f[key]
+            hash["facet.field"] << key
+            hash["f.#{key}.facet.sort"] = (value[:sort] == :count) if value[:sort]
+            hash["f.#{key}.facet.limit"] = value[:limit]
+            hash["f.#{key}.facet.missing"] = value[:missing]
+            hash["f.#{key}.facet.mincount"] = value[:mincount]
+            hash["f.#{key}.facet.prefix"] = value[:prefix]
+            hash["f.#{key}.facet.offset"] = value[:offset]
+          else
+            hash["facet.field"] << f
+          end
+        end
+      end
+      
+      if @params[:date_facets]
+        hash["facet.date"] = []
+        if @params[:date_facets][:fields]
+          @params[:date_facets][:fields].each do |f|
+            if f.kind_of? Hash
+              key = f.keys[0]
+              hash["facet.date"] << key
+              f[key].each { |k, v|
+                hash["f.#{key}.facet.date.#{k}"] = v
+              }
+            else
+              hash["facet.date"] << f
+            end
+          end
+        end
+        hash["facet.date.start"] = @params[:date_facets][:start]
+        hash["facet.date.end"] = @params[:date_facets][:end]
+        hash["facet.date.gap"] = @params[:date_facets][:gap]
+        hash["facet.date.other"] = @params[:date_facets][:other]
+        hash["facet.date.hardend"] = @params[:date_facets][:hardend]
+        if @params[:date_facets][:filter]
+          if hash[:fq]
+            hash[:fq] << @params[:date_facets][:filter]
+          else
+            hash[:fq] = @params[:date_facets][:filter]
+          end
+        end
+      end
+    end
+    
+    # highlighting parameter processing - http://wiki.apache.org/solr/HighlightingParameters
+    if @params[:highlighting]
+      hash[:hl] = true
+      hash["hl.fl"] = @params[:highlighting][:field_list].join(',') if @params[:highlighting][:field_list]
+
+      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
+
+      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]
+      hash[:mlt] = true
+      hash["mlt.count"] = @params[:mlt][:count]
+      hash["mlt.fl"] = @params[:mlt][:field_list].join(',')
+      hash["mlt.mintf"] = @params[:mlt][:min_term_freq]
+      hash["mlt.mindf"] = @params[:mlt][:min_doc_freq]
+      hash["mlt.minwl"] = @params[:mlt][:min_word_length]
+      hash["mlt.maxwl"] = @params[:mlt][:max_word_length]
+      hash["mlt.maxqt"] = @params[:mlt][:max_query_terms]
+      hash["mlt.maxntp"] = @params[:mlt][:max_tokens_parsed]
+      hash["mlt.boost"] = @params[:mlt][:boost]
+    end
+    
+    hash.merge(super.to_hash)
+  end
+
+end