mebla 1.0.0.rc2

data/lib/mebla/context.rb

@@ -0,0 +1,225 @@
+# @private
+module Mebla
+  # Handles indexing and reindexing
+  class Context    
+    attr_reader  :indexed_models, :slingshot_index, :slingshot_index_name
+    attr_reader  :mappings
+    
+    # @private
+    def initialize            
+      @indexed_models = []
+      @mappings = {}
+      @slingshot_index = Slingshot::Index.new(Mebla::Configuration.instance.index)
+      @slingshot_index_name = Mebla::Configuration.instance.index
+    end
+    
+    # @private
+    # Adds a model to the list of indexed models
+    def add_indexed_model(model, mappings = {})      
+      model = model.name if model.is_a?(Class)
+      
+      @indexed_models << model
+      @indexed_models.uniq!
+      @indexed_models.sort!
+      
+      @mappings.merge!(mappings)
+    end
+    
+    # Deletes and rebuilds the index
+    # @note Doesn't index the data, use Mebla::Context#reindex_data to rebuild the index and index the data
+    # @return [nil]
+    def rebuild_index
+      # Only rebuild if the index exists
+      raise ::Mebla::Errors::MeblaIndexException.new("#{@slingshot_index_name} does not exist !! use #create_index to create the index first.") unless index_exists?
+
+      ::Mebla.log("Rebuilding index")      
+      
+      # Delete the index
+      if drop_index
+        # Create the index
+        return build_index
+      end
+    end
+    
+    # Creates and indexes the document
+    # @note Doesn't index the data, use Mebla::Context#index_data to create the index and index the data
+    # @return [Boolean] true if operation is successful
+    def create_index
+      # Only create the index if it doesn't exist
+      raise ::Mebla::Errors::MeblaIndexException.new("#{@slingshot_index_name} already exists !! use #rebuild_index to rebuild the index.") if index_exists?
+      
+      ::Mebla.log("Creating index")
+      
+      # Create the index
+      build_index
+    end
+    
+    # Deletes the index of the document
+    # @return [Boolean] true if operation is successful
+    def drop_index
+      # Only drop the index if it exists
+      return true unless index_exists?
+      
+      ::Mebla.log("Dropping index: #{self.slingshot_index_name}", :debug)
+      
+      # Drop the index
+      result = @slingshot_index.delete
+      
+      ::Mebla.log("Dropped #{self.slingshot_index_name}: #{result.to_s}", :debug)
+      
+      # Check that the index doesn't exist
+      !index_exists?
+    end
+    
+    # Checks if the index exists and is available
+    # @return [Boolean] true if the index exists and is available, false otherwise
+    def index_exists?
+      begin
+        result = Slingshot::Configuration.client.get "#{Mebla::Configuration.instance.url}/#{@slingshot_index_name}/_status"
+        return (result =~ /error/) ? false : true
+      rescue RestClient::ResourceNotFound
+        return false
+      end
+    end
+    
+    # Creates the index and indexes the data for all models or a list of models given
+    # @param *models a list of symbols each representing a model name to be indexed
+    # @return [nil]
+    def index_data(*models)
+      if models.empty?
+        only_index = @indexed_models
+      else
+        only_index = models.collect{|m| m.to_s}
+      end
+      
+      ::Mebla.log("Indexing #{only_index.join(", ")}", :debug)
+      
+      # Build up a bulk query to save processing and time
+      bulk_query = ""
+      # Keep track of indexed documents
+      indexed_count = {}
+      
+      # Create the index
+      if create_index
+        # Start collecting documents
+        only_index.each do |model|
+          ::Mebla.log("Indexing: #{model}")
+          # Get the class
+          to_index = model.camelize.constantize
+          
+          # Get the records    
+          entries = []
+          unless to_index.embedded?
+            entries = to_index.all.only(to_index.search_fields)            
+          else
+            parent = to_index.embedded_parent
+            access_method = to_index.embedded_as
+            
+           parent.all.each do |parent_record|
+              entries += parent_record.send(access_method.to_sym).all.only(to_index.search_fields)
+            end
+          end
+          
+          # Save the number of entries to be indexed
+          indexed_count[model] = entries.count
+          
+          # Build the queries for this model          
+          entries.each do |document|
+            attrs = document.attributes.dup # make sure we dont modify the document it self
+            attrs["id"] = attrs.delete("_id") # the id is already added in the meta data of the action part of the query
+            
+            if document.embedded?
+              parent_id = document.send(document.class.embedded_parent_foreign_key.to_sym).id.to_s        
+              attrs[(document.class.embedded_parent_foreign_key + "_id").to_sym] = parent_id
+              
+              # Build add to the bulk query
+              bulk_query << build_bulk_query(@slingshot_index_name, to_index.slingshot_type_name, document.id.to_s, attrs, parent_id)
+            else
+              # Build add to the bulk query
+              bulk_query << build_bulk_query(@slingshot_index_name, to_index.slingshot_type_name, document.id.to_s, attrs)
+            end
+          end
+        end
+      else
+        raise ::Mebla::Errors::MeblaIndexException.new("Could not create #{@slingshot_index_name}!!!")
+      end
+      
+      # Add a new line to the query
+      bulk_query << '\n'
+      
+      ::Mebla.log("Bulk indexing:\n#{bulk_query}", :debug)
+      
+      # Send the query
+      response = Slingshot::Configuration.client.post "#{Mebla::Configuration.instance.url}/_bulk", bulk_query
+      
+      # Only refresh the index if no error ocurred
+      unless response =~ /error/                              
+        # Log results
+        ::Mebla.log("Indexed #{only_index.count} model(s) to #{self.slingshot_index_name}: #{response}")
+        ::Mebla.log("Indexing Report:")
+        indexed_count.each do |model_name, count|
+          ::Mebla.log("Indexed #{model_name}: #{count} document(s)")
+        end
+        
+        # Refresh the index
+        refresh_index
+      else
+        raise ::Mebla::Errors::MeblaIndexException.new("Indexing #{only_index.join(", ")} failed with the following response:\n #{response}")
+      end
+    rescue RestClient::Exception => error
+      raise ::Mebla::Errors::MeblaIndexException.new("Indexing #{only_index.join(", ")} failed with the following error: #{error.message}")
+    end
+    
+    # Rebuilds the index and indexes the data for all models or a list of models given
+    # @param *models a list of symbols each representing a model name to rebuild it's index
+    # @return [nil]
+    def reindex_data(*models)   
+      ::Mebla.log("Rendexing: #{self.slingshot_index_name}")
+      
+      unless drop_index
+        raise ::Mebla::Errors::MeblaIndexException.new("Could not drop #{@slingshot_index_name}!!!")
+      end        
+      
+      # Create the index and index the data
+      index_data(models)      
+    end
+        
+    # Refreshes the index
+    # @return [nil]
+    def refresh_index
+      ::Mebla.log("Refreshing: #{self.slingshot_index_name}", :debug)
+      
+      result = @slingshot_index.refresh
+      
+      ::Mebla.log("Refreshed #{self.slingshot_index_name}: #{result}")
+    end
+    
+    private          
+    # Builds the index according to the mappings set
+    # @return [Boolean] true if the index was created successfully, false otherwise
+    def build_index 
+      ::Mebla.log("Building index", :debug)
+      # Create the index
+      result = @slingshot_index.create :mappings => @mappings 
+      
+      ::Mebla.log("Created index: #{result.to_s}")
+      
+      # Check if the index exists
+      index_exists?
+    end
+    
+    # --
+    # OPTIMIZE: should find a solution for not refreshing the index while indexing embedded documents
+    # ++
+
+    # Builds a bulk index query
+    # @return [String]
+    def build_bulk_query(index_name, type, id, attributes, parent = nil)
+      attrs_to_json = attributes.collect{|k,v| "\"#{k}\" : \"#{v}\""}.join(", ")
+      <<-eos
+        { "index" : { "_index" : "#{index_name}", "_type" : "#{type}", "_id" : "#{id}"#{", \"_parent\" : \"#{parent}\"" if parent}, "refresh" : "true"} }
+        {#{attrs_to_json}}
+      eos
+    end
+  end
+end

data/lib/mebla/errors/mebla_configuration_exception.rb

@@ -0,0 +1,10 @@
+# @private
+module Mebla
+  # @private
+  module Errors
+    # Thrown when configuration fails
+    # @note this is a fatal exception
+    class MeblaIndexException < MeblaFatal
+    end  
+  end
+end

data/lib/mebla/errors/mebla_error.rb

@@ -0,0 +1,14 @@
+# @private
+module Mebla
+  # @private
+  module Errors
+    # Default parent Mebla error for all custom non-fatal errors.
+    class MeblaError < ::StandardError      
+      def initialize(message)
+        super message
+        ::ActiveSupport::Notifications.
+          instrument('mebla_error.mebla', :message => message)
+      end
+    end  
+  end
+end

data/lib/mebla/errors/mebla_fatal.rb

@@ -0,0 +1,14 @@
+# @private
+module Mebla
+  # @private
+  module Errors
+    # Default parent Mebla error for all custom fatal errors.
+    class MeblaFatal < ::StandardError
+      def initialize(message)
+        super message
+        ::ActiveSupport::Notifications.
+          instrument('mebla_fatal.mebla', :message => message)
+      end
+    end  
+  end
+end

data/lib/mebla/errors/mebla_index_exception.rb

@@ -0,0 +1,10 @@
+# @private
+module Mebla
+  # @private
+  module Errors
+    # Thrown when an index operation fails
+    # @note this is a fatal exception
+    class MeblaIndexException < MeblaFatal
+    end  
+  end
+end

data/lib/mebla/errors/mebla_synchronization_exception.rb

@@ -0,0 +1,9 @@
+# @private
+module Mebla
+  # @private
+  module Errors
+    # Thrown when a synchronization operation fails
+    class MeblaSynchronizationException < MeblaError      
+    end  
+  end
+end

data/lib/mebla/log_subscriber.rb

@@ -0,0 +1,77 @@
+require 'active_support/log_subscriber'
+
+# @private
+module Mebla
+  # Handles logging
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    # Debug message
+    def mebla_debug(event)
+      debug_green event.payload[:message]      
+    end
+
+    # Error message
+    def mebla_error(event)
+      error_red event.payload[:message]
+    end
+    
+    # Info message    
+    def mebla_info(event)
+      info_blue event.payload[:message]
+    end
+    
+    # Fatal message
+    def mebla_fatal(event)
+      fatal_magenta event.payload[:message]
+    end
+
+    # Warning message
+    def mebla_warn(event)
+      warn_yellow event.payload[:message]
+    end
+    
+    # Unkown message
+    def mebla_unkown(event)
+      unkown event.payload[:message]
+    end
+    
+    # --
+    # -------------------------------------------------------------
+    # Add some colors
+    # -------------------------------------------------------------
+    # ++
+    
+    # Print a debug message to the log file
+    def debug_green(msg)
+      debug color(msg, LogSubscriber::Green)
+    end
+    
+    # Print an error message to the log file
+    def error_red(msg)
+      error color(msg, LogSubscriber::RED)
+    end
+    
+    # Print an info message to the log file
+    def info_blue(msg)
+      ingo color(msg, LogSubscriber::BLUE)
+    end
+    
+    # Print a fatal message to the log file
+    def fatal_magenta(msg)
+      fatal color(msg, LogSubscriber::MAGENTA)
+    end
+    
+    # Print a warn message to the log file
+    def warn_yellow(msg)
+      warn color(msg, LogSubscriber::YELLOW)
+    end
+    
+    # Returns the main logger for Mebla
+    # @return [Logger]
+    def logger
+      Mebla::Configuration.instance.logger
+    end
+  end    
+end
+
+# Register the logger
+Mebla::LogSubscriber.attach_to :mebla

data/lib/mebla/mongoid/mebla.rb

@@ -0,0 +1,258 @@
+# @private
+module Mongoid
+  # --
+  # TODO: add ability to index embedded documents (as part of the parent document)
+  # ++
+  
+  # A wrapper for slingshot  elastic-search adapter for Mongoid
+  module Mebla
+    extend ActiveSupport::Concern
+    included do
+      # Used to properly represent data types
+      unless defined?(SLINGSHOT_TYPE_MAPPING)
+        SLINGSHOT_TYPE_MAPPING = {
+          'Array' => 'array',
+          'Date' => 'date',
+          'DateTime' => 'date',
+          'Time' => 'date',
+          'Float' => 'float',
+          'Integer' => 'integer',
+          'BigDecimal' => 'float',
+          'Boolean' => 'boolean'          
+        }
+      end
+      
+      cattr_accessor  :embedded_as      
+      cattr_accessor  :embedded_parent
+      cattr_accessor  :embedded_parent_foreign_key      
+      cattr_accessor  :index_mappings
+      cattr_accessor  :index_options
+      cattr_accessor  :search_fields        
+      cattr_accessor  :whiny_indexing   # set to true to raise errors if indexing fails
+      
+      # make sure critical data remain read only
+      private_class_method :"search_fields=", :"index_options=", :"index_mappings=",
+                                          :"embedded_parent_foreign_key=", :"embedded_parent=", :"embedded_as="
+      
+      # add callbacks to synchronize modifications with elasticsearch
+      after_save        :add_to_index
+      before_destroy :remove_from_index
+      
+      # by default if synchronizing fails no error is raised
+      self.whiny_indexing = false
+    end
+    
+    module ClassMethods
+      # Defines which fields should be indexed and searched
+      # @param [*opts] fields
+      # @return [nil]
+      #      
+      # Defines a search index on a normal document with custom mappings on "body"::
+      #
+      #  class Document
+      #   include Mongoid::Document
+      #   include Mongoid::Mebla
+      #   field :title
+      #   field :body
+      #   field :publish_date, :type => Date
+      #   #...
+      #   search_in :title, :publish_date, :body => { :boost => 2.0, :analyzer => 'snowball' }
+      #  end
+      #      
+      # Defines a search index on an embedded document with a single parent and custom mappings on "body"::
+      #
+      #  class Document
+      #   include Mongoid::Document
+      #   include Mongoid::Mebla
+      #   field :title
+      #   field :body
+      #   field :publish_date, :type => Date
+      #   #...
+      #   embedded_in :category
+      #   search_in :title, :publish_date, :body => { :boost => 2.0, :analyzer => 'snowball' }, :embedded_in => :category
+      #  end      
+      def search_in(*opts)
+        # Extract advanced indeces
+        options = opts.extract_options!.symbolize_keys
+        # Extract simple indeces
+        attrs = opts.flatten
+        
+        
+        # If this document is embedded check for the embedded_in option and raise an error if none is specified
+        # Example::
+        #  embedded in a regular class (e.g.: using the default convention for naming the foreign key)
+        #    :embedded_in => :parent        
+        if self.embedded?
+          if (embedor = options.delete(:embedded_in))
+            relation = self.relations[embedor.to_s]
+            
+            # Infer the attributes of the relation
+            self.embedded_parent = relation.class_name.constantize
+            self.embedded_parent_foreign_key = relation.key.to_s
+            self.embedded_as = relation[:inverse_of] || relation.inverse_setter.to_s.gsub(/=$/, '')            
+            
+            if self.embedded_as.blank?
+              raise ::Mebla::Errors::MeblaConfigurationException.new("Couldn't infer #{embedor.to_s} inverse relation, please set :inverse_of option on the relation.")
+            end
+          else
+            raise ::Mebla::Errors::MeblaConfigurationException.new("#{self.model_name} is embedded: embedded_in option should be set to the parent class if the document is embedded.")
+          end
+        end
+        
+        # Keep track of searchable fields (for indexing)
+        self.search_fields = attrs + options.keys
+        
+        # Generate simple indeces' mappings
+        attrs_mappings = {}
+        
+        attrs.each do |attribute|
+          attrs_mappings[attribute] = {:type => SLINGSHOT_TYPE_MAPPING[self.fields[attribute.to_s].type.to_s] || "string"}
+        end
+        
+        # Generate advanced indeces' mappings
+        opts_mappings = {}
+        
+        options.each do |opt, properties|          
+          opts_mappings[opt] = {:type => SLINGSHOT_TYPE_MAPPING[self.fields[opt.to_s].type.to_s] || "string" }.merge!(properties)
+        end
+        
+        # Merge mappings
+        self.index_mappings = {}.merge!(attrs_mappings).merge!(opts_mappings)        
+        
+        # Keep track of indexed models (for bulk indexing)
+        ::Mebla.context.add_indexed_model(self, self.slingshot_type_name.to_sym => prepare_mappings)
+      end
+            
+      # Searches the model using Slingshot search DSL
+      # @return [ResultSet]
+      #
+      # Search for posts with the title 'Testing Search'::
+      #
+      #  Post.search do
+      #   query do
+      #    string "title: Testing Search"
+      #   end
+      #  end
+      #
+      # @note For more information about Slingshot search DSL, check http://karmi.github.com/slingshot
+      def search(&block)
+        ::Mebla.search(self.slingshot_type_name, &block)
+      end
+      
+      # Retrieves the type name of the model 
+      # (used to populate the _type variable while indexing)
+      # @return [String]
+      def slingshot_type_name #:nodoc:
+        "#{self.model_name.underscore}"
+      end
+      
+      # Enables the modification of records without indexing
+      # @return [nil]
+      # Example::
+      #  create record without it being indexed
+      #    Class.without_indexing do
+      #      create :title => "This is not indexed", :body => "Nothing will be indexed within this block"      
+      #    end
+      # @note you can skip indexing to create, update or delete records without affecting the index
+      def without_indexing(&block)
+        skip_callback(:save, :after, :add_to_index)
+        skip_callback(:destroy, :before, :remove_from_index)
+        yield
+        set_callback(:save, :after, :add_to_index)
+        set_callback(:destroy, :before, :remove_from_index)
+      end
+      
+      private
+      # Prepare the mappings required for this document
+      # @return [Hash]
+      def prepare_mappings
+        if self.embedded?
+          mappings = {
+            :_parent => { :type => self.embedded_parent.name.underscore },
+            :_routing => {
+              :required => true,
+              :path => self.embedded_parent_foreign_key  + "_id"
+            }
+          }
+        else
+          mappings = {}
+        end
+        
+        mappings.merge!({
+          :properties => self.index_mappings
+        })
+      end
+    end
+    
+    private
+    # Adds the document to the index
+    # @return [Boolean] true if the operation is successful
+    def add_to_index
+      return false unless ::Mebla.context.index_exists? # only try to index if the index exists      
+      
+      # Prepare attributes to hash
+      to_index_hash = {:id => self.id.to_s}
+      
+      # If the document is embedded set _parent to the parent's id
+      if self.embedded?
+        parent_id = self.send(self.class.embedded_parent_foreign_key.to_sym).id.to_s        
+        to_index_hash.merge!({ 
+          (self.class.embedded_parent_foreign_key + "_id").to_sym => parent_id,
+          :_parent => parent_id
+        })
+      end
+      
+      # Add indexed fields to the hash
+      self.search_fields.each do |sfield|
+        to_index_hash[sfield] = self.attributes[sfield]
+      end      
+      
+      ::Mebla.log("Indexing #{self.class.slingshot_type_name}: #{to_index_hash.to_s}", :debug)
+      
+      # Index the data under its correct type
+      response = ::Mebla.context.slingshot_index.store(self.class.slingshot_type_name.to_sym, to_index_hash)
+      
+      ::Mebla.log("Response for indexing #{self.class.slingshot_type_name}: #{response.to_s}", :debug)
+      
+      # Refresh the index
+      ::Mebla.context.refresh_index
+      return true
+    rescue => error
+      raise_synchronization_exception(error)
+      
+      return false
+    end
+        
+    # Deletes the document from the index
+    # @return [Boolean] true if the operation is successful
+    def remove_from_index
+      return false unless ::Mebla.context.index_exists? # only try to index if the index exists      
+      
+      ::Mebla.log("Removing #{self.class.slingshot_type_name} with id: #{self.id.to_s}", :debug)
+
+      # Delete the document
+      response = Slingshot::Configuration.client.delete "#{::Mebla::Configuration.instance.url}/#{::Mebla.context.slingshot_index_name}/#{self.class.slingshot_type_name}/#{self.id.to_s}"
+      
+      ::Mebla.log("Response for removing #{self.class.slingshot_type_name}: #{response.to_s}", :debug)
+      
+      # Refresh the index
+      ::Mebla.context.refresh_index
+      return true
+    rescue => error
+      raise_synchronization_exception(error)
+      
+      return false
+    end
+    
+    def raise_synchronization_exception(error)
+      exception_message = "#{self.class.slingshot_type_name} synchronization failed with the following error: #{error.message}"
+      if self.class.whiny_indexing
+        # Whine when mebla is not able to synchronize
+        raise ::Mebla::Errors::MeblaSynchronizationException.new(exception_message)
+      else
+        # Whining is not allowed, silently log the exception
+        ::Mebla.log(exception_message, :warn)
+      end
+    end
+  end
+end

data/lib/mebla/railtie.rb

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