rmla 1.0

data/lib/mebla/railtie.rb

@@ -0,0 +1,39 @@
+require 'mebla'
+require 'rails'
+
+# A wrapper for slingshot  elastic-search adapter for Mongoid
+module Mebla
+  # @private
+  # Railtie for Mebla
+  class Railtie < Rails::Railtie
+    # Configuration
+     initializer "mebla.set_configs" do |app|
+      Mebla.configure do |config|
+        # Open logfile
+        config.logger = ActiveSupport::BufferedLogger.new(
+          open("#{Dir.pwd}/log/#{Rails.env}.mebla.log", "a")
+        )
+        # Setup the log level
+        config.logger.level = case app.config.log_level
+          when :info
+            ActiveSupport::BufferedLogger::Severity::INFO
+          when :warn
+            ActiveSupport::BufferedLogger::Severity::WARN          
+          when :error
+            ActiveSupport::BufferedLogger::Severity::ERROR
+          when :fatal
+            ActiveSupport::BufferedLogger::Severity::FATAL
+          else
+            ActiveSupport::BufferedLogger::Severity::DEBUG
+          end
+          
+        config.setup_logger
+      end
+    end    
+    
+    # Rake tasks
+    rake_tasks do
+      load File.expand_path('../tasks.rb', __FILE__)
+    end
+  end
+end

data/lib/mebla/result_set.rb

@@ -0,0 +1,91 @@
+# A wrapper for slingshot  elastic-search adapter for Mongoid
+module Mebla
+  # Represents a set of search results  
+  class ResultSet
+    include Enumerable
+    attr_reader :entries, :facets, :time, :total
+    
+    # --
+    # OPTIMIZE: needs major refractoring
+    # ++
+    
+    # Creates a new result set from an elasticsearch response hash
+    # @param response
+    def initialize(response)
+      # Keep the query time
+      @time = response['took'] 
+      # Keep the facets      
+      @facets = response['facets']
+      # Keep the query total to check against the count 
+      @total = response['hits']['total']       
+      
+      # Be efficient only query the database once
+      model_ids = []
+      
+      # Collect results' ids
+      response['hits']['hits'].each do |hit|
+        model_class = hit['_type'].camelize.constantize        
+        model_ids << [model_class]
+
+        if model_class.embedded?
+          model_class_collection = model_ids.assoc(model_class)
+          # collect parent ids
+          # [class, [parent_id, ids]]
+          parent_id = hit['_source']['_parent']
+          
+          model_class_collection << [parent_id]
+          
+          model_class_collection.assoc(parent_id) << hit['_source']['id']
+        else
+          # collect ids
+          # [class, ids]
+          model_ids.assoc(model_class) << hit['_source']['id']
+        end
+      end
+      
+      # Cast the results into their appropriate classes
+      @entries = []
+
+      model_ids.each do |model_class_collection|          
+        model_class = model_class_collection.first
+        ids = model_class_collection.drop(1)
+
+        unless model_class.embedded?
+          # Retrieve the results from the database
+          ids.each do |id|
+            @entries << model_class.find(id)
+          end
+        else
+          # Get the parent
+          parent_class = model_class.embedded_parent
+          access_method = model_class.embedded_as
+          
+          ids.each do |parent_id_collection|
+            parent_id = parent_id_collection.first
+            entries_ids = parent_id_collection.drop(1)
+            
+            parent = parent_class.find parent_id
+            
+            # Retrieve the results from the database
+            entries_ids.each do |entry_id|
+              @entries << parent.send(access_method.to_sym).find(entry_id)
+            end
+          end
+        end
+      end
+            
+      Mebla.log("WARNING: Index not synchronized with the database; index total hits: #{@total}, retrieved documents: #{self.count}", :warn) if @total != self.count
+    end
+    
+    # Iterates over the collection    
+    def each(&block)
+      @entries.each(&block)
+    end
+    
+    # Returns the item with the given index
+    # @param [Integer] index
+    def [](index)
+      @entries[index]
+    end
+  end
+end

data/lib/mebla/search.rb

@@ -0,0 +1,240 @@
+# A wrapper for slingshot  elastic-search adapter for Mongoid
+module Mebla
+  # Handles all searching functions and chains search to define filters, sorting or facets.
+  #
+  # This example searches posts by tags, sorts and filters the results::
+  #  
+  # criteria = Post.search.terms(:tags, ['ruby', 'rails']).ascending(:publish_date).only(:author => ['cousine'])
+  #
+  # This will search the index for posts tagged 'ruby' or 'rails', arrange the results ascendingly according
+  # to their publish dates, and filter the results by the author named 'cousine'.
+  #
+  # The search won't be executed unless we try accessing the results collection::
+  #
+  #  results = criteria.hits
+  #
+  # Or directly iterate the collection::
+  #
+  #  criteria.each do |result|
+  #    ...
+  #  end
+  #
+  # Mebla supports multiple methods of searching
+  # 
+  # You can either search by direct Lucene query::
+  #  
+  #  Mebla.search("query")
+  #
+  # Or by term::
+  #
+  #  Mebla.search.term(:field, "term")
+  #
+  # Or by terms::
+  #
+  #  Mebla.search.terms(:field, ["term 1", "term 2", ...])  
+  class Search
+    include Enumerable
+    attr_reader :slingshot_search, :results    
+    
+    # Creates a new Search object
+    # @param [String] query_string optional search query
+    # @param [String, Symbol, Array] type_names a string, symbol or array representing the models to be searcheds
+    def initialize(query_string = "", type_names = [])
+      # Convert type names from string or symbol to array
+      type_names = case true
+        when type_names.is_a?(Symbol), type_names.is_a?(String)
+          [type_names]      
+        when type_names.is_a?(Array) && !type_names.empty?
+          type_names.collect{|name| name.to_s}
+        else
+          []
+        end
+        
+        @slingshot_search = Slingshot::Search::Search.new(Mebla.context.slingshot_index_name, {})
+        # Add a type filter to return only certain types
+        unless type_names.empty?
+          only(:_type => type_names)
+        end
+        
+        unless query_string.blank?
+          query(query_string)
+        end
+    end
+    
+    # Creates a terms search criteria
+    # @param [String, Symbol] field the field to search
+    # @param [Array] values the terms to match
+    # @param [Hash] options to refine the search
+    # @return [Mebla::Search]
+    #
+    # Match Posts tagged with either 'ruby' or 'rails'::
+    #
+    #  Post.search.terms(:tags, ['ruby', 'rails'], :minimum_match => 1)
+    def terms(field, values, options = {})      
+      @slingshot_search = @slingshot_search.query
+      @slingshot_search.instance_variable_get(:@query).terms(field, values, options)
+      self
+    end
+    
+    # Creates a term search criteria
+    # @param [String, Symbol] field the field to search
+    # @param [String] value term to match
+    # @return [Mebla::Search]
+    def term(field, value)
+      @slingshot_search = @slingshot_search.query
+      @slingshot_search.instance_variable_get(:@query).term(field, value)
+      self
+    end
+    
+    # Creates a Lucene query string search criteria
+    # @param [String] query_string search query
+    # @param [Hash] options to refine the search
+    #
+    # Match Posts with "Test Lucene query" as title::
+    #
+    #  Post.search.query("Test Lucene query", :default_field => "title")
+    # 
+    # You can also instead::
+    #
+    #  Post.search.query("title: Test Lucene query")
+    #
+    # Or to search all fields::
+    #
+    #  Post.search.query("Test Lucene query")
+    #
+    # @note For more information check {http://lucene.apache.org/java/2_4_0/queryparsersyntax.html  Lucene's query syntax}
+    def query(query_string, options = {})
+      @slingshot_search = @slingshot_search.query
+      @slingshot_search.instance_variable_get(:@query).string(query_string, options)
+      self
+    end
+    
+    # Sorts results ascendingly
+    # @param [String, Symbol] field to sort by
+    # @return [Mebla::Search]
+    def ascending(field)
+      @slingshot_search = @slingshot_search.sort
+      @slingshot_search.instance_variable_get(:@sort).send(field.to_sym, 'asc')
+      self
+    end
+    
+    # Sorts results descendingly
+    # @param [String, Symbol] field to sort by
+    # @return [Mebla::Search]
+    def descending(field)
+      @slingshot_search = @slingshot_search.sort
+      @slingshot_search.instance_variable_get(:@sort).send(field.to_sym, 'desc')
+      self
+    end
+    
+    # Creates a new facet for the search
+    # @param [String] name of the facet
+    # @param [String, Symbol] field to create a facet for
+    # @param [Hash] options
+    # @return [Mebla::Search]
+    #
+    # Defining a global facet named "tags"::
+    #
+    #  Post.search("*").facet("tags", :tag, :global => true)
+    # 
+    # @note check {http://www.elasticsearch.org/guide/reference/api/search/facets/ elasticsearch's facet reference} for more information
+    def facet(name, field, options={})
+      # Get the hash
+      facet_hash = @slingshot_search.instance_variable_get(:@facets)
+      # Create a new Facet
+      facet_obj = Slingshot::Search::Facet.new(name, options)
+      facet_obj.terms(field)
+      # Initialize the hash if its nil
+      if facet_hash.nil?
+        @slingshot_search.instance_variable_set(:@facets, {})
+      end
+      # Add the facet to the hash
+      @slingshot_search.instance_variable_get(:@facets).update facet_obj.to_hash        
+      self
+    end
+    
+    # Filters the results according to the criteria
+    # @param [*Hash] fields hash for each filter
+    # @return [Mebla::Search]
+    # 
+    # Get all indexed Posts and filter them by tags and authors::
+    #
+    #  Post.search("*").only(:tag => ["ruby", "rails"], :author => ["cousine"])
+    def only(*fields)
+      return if fields.empty?
+      fields.each do |field|
+        @slingshot_search = @slingshot_search.filter(:terms, field)
+      end
+      self
+    end
+    
+    # Sets the maximum number of hits per query, defaults to 10
+    # @param [Integer] value
+    # @return [Mebla::Search]
+    def size(value)
+      @slingshot_search = @slingshot_search.size(value)
+      self
+    end
+    
+    # Sets the starting offset for the query
+    # @param [Integer] value
+    # @return [Mebla::Search]
+    def from(value)
+      @slingshot_search = @slingshot_search.from(value)
+      self
+    end
+    
+    # Performs the search and returns the results
+    # @return [Mebla::ResultSet]
+    def hits
+      return @results if @results
+      # Log search query
+      Mebla.log("Searching:\n#{@slingshot_search.to_json.to_s}", :debug)
+      response = @slingshot_search.perform.json
+      Mebla.log("Response:\n#{response.to_json.to_s}", :info)
+      @results = Mebla::ResultSet.new(response)
+      # Log results statistics
+      Mebla.log("Searched for:\n#{@slingshot_search.to_json.to_s}\ngot #{@results.total} documents in #{@results.time} ms", :debug)
+      @results
+    end
+    
+    # Returns the internal results list
+    # @return [Array]
+    def entries
+      hits.entries
+    end
+    
+    # Retrieves the total number of hits
+    # @return [Integer]
+    def total
+      hits.total
+    end
+    
+    # Retrieves the time taken to perform the search in ms
+    # @return [Float]
+    def time
+      hits.time
+    end
+    
+    # Retrieves the facets
+    # @return [Hash]
+    #
+    # Reading a facet named 'tags'::
+    #
+    #  facets = Post.search("*").facet("tags", :tag)
+    #  facets["terms"].each do |term|
+    #    puts "#{term['term']} - #{term['count']}"
+    #  end
+    def facets
+      hits.facets
+    end
+    
+    # Iterates over the results collection
+    def each(&block)
+      hits.each(&block)
+    end
+    
+    alias_method :asc, :ascending
+    alias_method :desc, :descending
+  end
+end

data/lib/mebla/tasks.rb

@@ -0,0 +1,49 @@
+namespace :mebla do
+  desc "Creates the indeces and indexes the data for all indexed models"
+  task :index => :environment do
+    setup
+    @context.index_data
+  end
+  
+  desc "Drops then creates the indeces and indexes the data for all indexed models"
+  task :reindex => :environment do
+    setup
+    @context.reindex_data
+  end
+  
+  desc "Creates the index without indexing the data"
+  task :create_index => :environment do
+    setup
+    @context.create_index
+  end
+  
+  desc "Rebuilds the index without indexing the data"
+  task :rebuild_index => :environment do
+    setup
+    @context.rebuild_index
+  end
+  
+  desc "Drops the index"
+  task :drop_index => :environment do
+    setup
+    @context.drop_index
+  end
+  
+  desc "Refreshes the index"
+  task :refresh_index => :environment do
+    setup
+    @context.refresh_index
+  end
+end
+
+# @private
+# Sets up the logger and loads all the models
+def setup
+  Rails.application.eager_load!
+  Mebla.configure do |config|
+    config.logger = ActiveSupport::BufferedLogger.new(STDOUT)
+    config.logger.level = ActiveSupport::BufferedLogger::Severity::UNKNOWN
+    config.setup_logger
+  end
+  @context = Mebla.context
+end

data/mebla.gemspec

@@ -0,0 +1,113 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "rmla"
+  s.version = "1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new("<= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Youssef Hanna"]
+  s.date = "2012-01-04"
+  s.description = "\n    An elasticsearch wrapper for mongoid odm based on slingshot. Makes integration between ElasticSearch full-text \n    search engine and Mongoid documents seemless and simple.\n  "
+  s.email = "1@11.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "TODO.md",
+    "VERSION",
+    "lib/generators/mebla/install/USAGE",
+    "lib/generators/mebla/install/install_generator.rb",
+    "lib/generators/mebla/install/templates/mebla.yml",
+    "lib/mebla.rb",
+    "lib/mebla/configuration.rb",
+    "lib/mebla/context.rb",
+    "lib/mebla/errors.rb",
+    "lib/mebla/errors/mebla_configuration_exception.rb",
+    "lib/mebla/errors/mebla_error.rb",
+    "lib/mebla/errors/mebla_fatal.rb",
+    "lib/mebla/errors/mebla_index_exception.rb",
+    "lib/mebla/errors/mebla_synchronization_exception.rb",
+    "lib/mebla/log_subscriber.rb",
+    "lib/mebla/mongoid/mebla.rb",
+    "lib/mebla/railtie.rb",
+    "lib/mebla/result_set.rb",
+    "lib/mebla/search.rb",
+    "lib/mebla/tasks.rb",
+    "mebla.gemspec",
+    "spec/fixtures/models.rb",
+    "spec/fixtures/mongoid.yml",
+    "spec/mebla/indexing_spec.rb",
+    "spec/mebla/searching_spec.rb",
+    "spec/mebla/synchronizing_spec.rb",
+    "spec/mebla_helper.rb",
+    "spec/mebla_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/support/mongoid.rb",
+    "spec/support/rails.rb"
+  ]
+  s.homepage = "http://github.com/cousine/mebla"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.11"
+  s.summary = "An elasticsearch wrapper for mongoid odm based on slingshot."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<slingshot-rb>, ["= 0.0.8"])
+      s.add_runtime_dependency(%q<mongoid>, [">= 2.1.8"])
+      s.add_development_dependency(%q<bson_ext>, ["~> 1.3.1"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<yard>, ["~> 0.6.0"])
+      s.add_development_dependency(%q<mongoid-rspec>, ["~> 1.4.4"])
+      s.add_development_dependency(%q<database_cleaner>, ["= 0.6.4"])
+      s.add_development_dependency(%q<bluecloth>, ["~> 2.1.0"])
+      s.add_development_dependency(%q<irbtools>, [">= 0"])
+      s.add_development_dependency(%q<ruby-debug>, [">= 0"])
+      s.add_development_dependency(%q<ruby-debug19>, [">= 0"])
+    else
+      s.add_dependency(%q<slingshot-rb>, ["= 0.0.8"])
+      s.add_dependency(%q<mongoid>, [">= 2.1.8"])
+      s.add_dependency(%q<bson_ext>, ["~> 1.3.1"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<yard>, ["~> 0.6.0"])
+      s.add_dependency(%q<mongoid-rspec>, ["~> 1.4.4"])
+      s.add_dependency(%q<database_cleaner>, ["= 0.6.4"])
+      s.add_dependency(%q<bluecloth>, ["~> 2.1.0"])
+      s.add_dependency(%q<irbtools>, [">= 0"])
+      s.add_dependency(%q<ruby-debug>, [">= 0"])
+      s.add_dependency(%q<ruby-debug19>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<slingshot-rb>, ["= 0.0.8"])
+    s.add_dependency(%q<mongoid>, [">= 2.1.8"])
+    s.add_dependency(%q<bson_ext>, ["~> 1.3.1"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<yard>, ["~> 0.6.0"])
+    s.add_dependency(%q<mongoid-rspec>, ["~> 1.4.4"])
+    s.add_dependency(%q<database_cleaner>, ["= 0.6.4"])
+    s.add_dependency(%q<bluecloth>, ["~> 2.1.0"])
+    s.add_dependency(%q<irbtools>, [">= 0"])
+    s.add_dependency(%q<ruby-debug>, [">= 0"])
+    s.add_dependency(%q<ruby-debug19>, [">= 0"])
+  end
+end
+