blodsband 0.0.2

data/lib/blodsband/riak/search.rb

@@ -0,0 +1,233 @@
+
+module Blodsband
+
+  class Riak
+
+    class Search
+
+      BOOLS = Set.new(["AND", "OR"])
+
+      #
+      # Create a search instance.
+      #
+      # @param [URI] url a {::URI} to the HTTP port of a Riak node with Riak Search enabled.
+      #
+      def initialize(url)
+        @url = url
+      end
+
+      # {include:Search#search}
+      #
+      # @param (see #search)
+      #
+      # @return [Blodsband::Future<Hash<Symbol, Object>>] an eventual {Hash} <code>:total => number_of_results, :results => [doc1, doc2, ...]</code>
+      #
+      def asearch(query, options = {})
+        options = options.clone
+        fields = options.delete(:fields)
+        if fields
+          asearch(multi_field_query(query, fields), options)
+        else
+          mult = Multi.new
+          mult.add(:resp, 
+                   client(URI.join(@url.to_s, 
+                                   "/solr/select")).
+                   aget(:query => query_with_options(query, options)))
+          return(Future.new do
+                   mult.really_perform
+                   response = mult.responses[:callback][:resp].response['response']
+                   rval = {
+                     :total => response['numFound'],
+                     :results => response['docs'].map do |x| 
+                       x['fields'] 
+                     end
+                   }
+                   class << rval
+                     attr_reader :max_score
+                   end
+                   rval.instance_eval do
+                     @max_score = response['maxScore']
+                   end
+                   rval
+                 end)
+        end
+      end
+
+      #
+      # Search for documents in Riak Search.
+      #
+      # @param [String] query the query to use when searching. See {http://wiki.basho.com/Riak-Search---Querying.html} for more information.
+      # @param [Hash<Symbol, Object>] options
+      #  :default_field:: [String] the default field to apply to all terms in the query that lack their own field specifications.
+      #  :per_page:: [Integer] the maximum number of hits to return.
+      #  :page:: [Integer] the page number (starting at 1) that you want returned
+      #  :fields:: [Array<String>] if you want to search for terms without field specification among multiple fields, provide <code>:fields</code> instead of <code>:default_field</code>. This will emulate (slightly) the dismax functionality of Solr by rewriting the query and adding each field you define to each unfielded term.
+      #
+      # @return [Hash<Symbol, Object>] a {Hash} <code>:total => number_of_results, :results => [doc1, doc2, ...]</code>
+      #
+      def search(query, options = {})
+        asearch(query, options).get
+      end
+
+      #
+      # {include:Search#index!}
+      #
+      # @param (see #index!)
+      #
+      # @return [Blodsband::Riak::Future<Object>] a future that returns when the indexing is finished.
+      #
+      def aindex!(document)
+        mult = Multi.new
+        mult.add(:resp, 
+                 client(URI.join(@url.to_s, 
+                                 "/solr/update")).
+                 apost(:head => { 'Content-Type' => 'text/xml' },
+                       :body => add_document_xml(document).to_s))
+        return(Future.new do
+                 mult.really_perform
+                 mult.responses[:callback][:resp].response
+               end)
+      end
+
+      #
+      # Index a document in Riak Search.
+      #
+      # @param [Hash] document the object to index. All keys and values will be used to create the indexed document.
+      #
+      def index!(document)
+        aindex!(document).get
+      end
+
+      private
+
+      #
+      # Split a string into an Array tree by parentheses, eg:
+      #
+      # "a (b c) (d (e f))" => ["a ", ["b c"], ["d ", ["e f"]]]
+      #
+      def parenthesize(string)
+        rval = []
+        add_parenthese_parts(rval, string)
+        rval
+      end
+
+      #
+      # Helper for #parenthesize, pushing next bit of result onto parent
+      #
+      def add_parenthese_parts(parent, string)
+        buffer = ""
+        while string.size > 0
+          char = string[0]
+          string = string[1..-1]
+          if char == "("
+            parent << buffer if buffer.size > 0
+            sub = []
+            string = add_parenthese_parts(sub, string)
+            parent << sub if sub.size > 0
+            buffer = ""
+          elsif char == ")"
+            parent << buffer if buffer.size > 0
+            return string
+          else
+            buffer << char
+          end
+        end
+        parent << buffer if buffer.size > 0
+        return string
+      end
+
+      #
+      # Use the result from a parenthesized query to add fields to all terms without fields without breaking
+      # the original logical structure of the query. Hopefully. This should not be necessary, but Riak Search has no
+      # dismax or similar query parser :/
+      #
+      def multifieldify(query_part, fields)
+        if query_part.is_a?(Array)
+          query_part.collect do |sub_part|
+            if sub_part.is_a?(Array)
+              "(#{multifieldify(sub_part, fields)})"
+            elsif sub_part.is_a?(String)
+              multifieldify(sub_part, fields)
+            end
+          end.join(" ")
+        elsif query_part.is_a?(String)
+          terms = []
+          while match = query_part.match(/^\s*(\w+:)?(("[^"]*")|(\S+))\s*(.*)/)
+            if match[1]
+              terms << "#{match[1]}#{match[2]}"
+            elsif BOOLS.include?(match[2])
+              terms << match[2]
+            else
+              terms << "("
+              fields.each do |field|
+                parts = field.split("^")
+                if parts.size == 1
+                  terms << "#{field}:#{match[2]}"
+                elsif parts.size == 2
+                  terms << "#{parts[0]}:#{match[2]}^#{parts[1]}"
+                else
+                  raise ("Illegal field declaration for #multi_field_query. " + 
+                         "Fields must look like 'fieldname' or 'fieldname^boost'")
+                end
+              end
+              terms << ")"
+            end
+            query_part = match[5]
+          end
+          terms.join(" ")
+        else
+          raise "Illegal query part type: #{query_part.inspect}. Only Array or String allowed."
+        end
+      end
+
+      #
+      # Make sure that all terms in query that have no fields defined get the provided fields.
+      #
+      def multi_field_query(query, fields)
+        multifieldify(parenthesize(query), fields)
+      end
+
+      def query_with_options(q, options = {})
+        query = { 
+          :q => q, 
+          :wt => 'json'
+        }
+        if options[:index]
+          query[:index] = options[:index]
+        end
+        if options[:page]
+          query[:start] = (options[:page] - 1) * (options[:per_page] || 10)
+        end
+        if options[:sort]
+          query[:sort] = options[:sort]
+        end
+        if options[:per_page]
+          query[:rows] = options[:per_page]
+        end
+        if options[:default_field]
+          query[:df] = options[:default_field]
+        end
+        query
+      end
+      
+      def client(url)
+        http = EventMachine::HttpRequest.new(url)
+        http.use EventMachine::Middleware::JSONResponse
+        http
+      end
+
+      def add_document_xml(document)
+        xml = REXML::Document.new('<add></add>')
+        doc_el = xml.root.add_element('doc')
+        document.each do |field,value|
+          field_el = doc_el.add_element('field', { 'name' => field })
+          field_el.text = value
+        end
+        xml
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/blodsband/riak/sset.rb

@@ -0,0 +1,104 @@
+
+module Blodsband
+  
+  class Riak
+
+    #
+    # A concurrent set. Named Sset to avoid colliding with ruby standard Set.
+    #
+    class Sset < List
+
+      #
+      # @param [Object] v a value to check if this set includes.
+      #
+      # @return [true,false] whether this set includes v.
+      #
+      def include?(v)
+        !bucket.get(key_for(v)).nil?
+      end
+
+      #
+      # @param [Array<Object>] values some values to check if they are included in this set.
+      #
+      # @return [Set<Object>] the values that are included in this set.
+      #
+      def retain(values)
+        map = values.inject({}) do |sum, value|
+          sum.merge(key_for(value) => value)
+        end
+        included = bucket.has_many?(map.keys)
+        Set.new(map.reject do |k, v|
+                  !included.include?(k)
+                end.values)
+      end
+
+      #
+      # @return [Set<Object>] this {Blodsband::Riak::Sset} as a ruby {::Set}.
+      #
+      def to_set
+        Set.new(to_a)
+      end
+
+      #
+      # @param [Blodsband::Riak::Sset] sset a {Blodsband::Riak::Sset} to intersect with this.
+      #
+      # @return [Set<Object>] a ruby {::Set} containing the intersection of this {Blodsband::Riak::Sset} and the argument.
+      #
+      def intersect(sset)
+        if size > sset.size
+          retain(sset.to_a)
+        else
+          sset.retain(to_a)
+        end
+      end
+
+      #
+      # @param [Object] v a value to remove from this set.
+      #
+      def delete(v)
+        element_key = bucket.get(key_for(v))
+        if element_key.nil?
+          nil
+        else
+          element = Element.find(self, element_key)
+          element.delete
+          element.value
+        end
+      end
+
+      protected
+
+      def ok_to_add?(new_element)
+        bucket.get(key_for(new_element.value)).nil?
+      end
+
+      def backlog_delete(new_element)
+        backlog << [:delete_element_pointer,
+                    key_for(new_element.value)]
+      end
+
+      def backlog_add(new_element)
+        backlog << [:add_element_pointer,
+                    new_element.key,
+                    key_for(new_element.value)]
+      end
+
+      def delete_element_pointer(key)
+        bucket.delete(key)
+      end
+
+      def add_element_pointer(element_key, key)
+        bucket.put(key, element_key, :riak_params => {:w => :all})
+      end
+
+      private
+
+      def key_for(value)
+        "#{key}_#{Digest::SHA1.hexdigest(Yajl::Encoder.encode(value)).to_i(16).to_s(36)}"
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: blodsband
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Martin Bruse
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: &70126645594260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70126645594260
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: &70126645593760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70126645593760
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: &70126645593300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70126645593300
+- !ruby/object:Gem::Dependency
+  name: mail
+  requirement: &70126645592800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70126645592800
+description: ! 'An event-machine based riak client with some extra relationship support.
+
+'
+email: zondolfin at gmail dot com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/blodsband/error.rb
+- lib/blodsband/future.rb
+- lib/blodsband/multi.rb
+- lib/blodsband/riak/bucket.rb
+- lib/blodsband/riak/counter.rb
+- lib/blodsband/riak/list.rb
+- lib/blodsband/riak/lock.rb
+- lib/blodsband/riak/map.rb
+- lib/blodsband/riak/mr.rb
+- lib/blodsband/riak/response.rb
+- lib/blodsband/riak/search.rb
+- lib/blodsband/riak/sset.rb
+- lib/blodsband/riak.rb
+- lib/blodsband.rb
+homepage: http://github.com/ProjectDaisy/blodsband
+licenses: []
+post_install_message: 
+rdoc_options:
+- --line-numbers
+- --inline-source
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: An event-machine based riak client with some extra relationship support.
+test_files: []
+has_rdoc: true