mongoid-giza 0.1.0

data/lib/mongoid/giza/dynamic_index.rb

@@ -0,0 +1,37 @@
+module Mongoid
+  module Giza
+
+    # Defines a dynamic index which is used to generate a index for each object of the class
+    class DynamicIndex
+      attr_reader :klass, :settings, :block
+
+      # Creates a new dynamic index for the supplied class
+      #
+      # @param klass [Class] a class which each object will generate an {Mongoid::Giza::Index}
+      #   after the evaluation of the block
+      # @param settings [Hash] a hash of settings to be defined on every generated index
+      # @param block [Proc] the routine that will be evaluated for each object from the class
+      def initialize(klass, settings, block)
+        @klass = klass
+        @settings = settings
+        @block = block
+      end
+
+      # Generates indexes for every object of the class.
+      # The name of the index is unique so in case of a name collision,
+      # the last index to be generated is the one that will persist
+      #
+      # @return [Hash<Symbol, Mongoid::Giza::Index] an hash with every key being the index name
+      #   and the value the index itself
+      def generate!
+        indexes = {}
+        klass.all.each do |object|
+          index = Mongoid::Giza::Index.new(klass, settings)
+          Docile.dsl_eval(index, object, &block)
+          indexes[index.name] = index
+        end
+        indexes
+      end
+    end
+  end
+end

data/lib/mongoid/giza/index.rb

@@ -0,0 +1,101 @@
+module Mongoid
+  module Giza
+
+    # Represents a Sphinx index
+    class Index
+
+      # Hash in which each key is a class accepted by +Mongoid+
+      # and its value is a compatible Sphix attribute type
+      TYPES_MAP = {
+        Regexp => :string,
+        String => :string,
+        Symbol => :string,
+        Boolean => :bool,
+        Integer => :bigint,
+        Date => :timestamp,
+        DateTime => :timestamp,
+        Time => :timestamp,
+        BigDecimal => :float,
+        Float => :float,
+        Array => :multi,
+        Range => :multi,
+        Hash => :json,
+        Moped::BSON::ObjectId => :string,
+        ActiveSupport::TimeWithZone => :timestamp,
+      }
+
+      attr_accessor :klass, :settings, :fields, :attributes
+
+      # Creates a new index with a class, which should include Mongoid::Document, and an optional settings hash.
+      #
+      # Note that no validations are made on class, so classes that behave like Mongoid::Document should be fine.
+      #
+      # @param klass [Class] the class whose objects will be indexed
+      # @param settings [Hash] an optional settings hash to be forwarded to Riddle
+      def initialize(klass, settings = {})
+        @klass = klass
+        @settings = settings
+        @name = @klass.name.to_sym
+        @criteria = klass.all
+        @fields = []
+        @attributes = []
+      end
+
+      # Adds a full-text field to the index with the corresponding name
+      #
+      # If a block is given then it will be evaluated for each instance of the class being indexed
+      # and the resulting string will be the field value.
+      # Otherwise the field value will be the value of the corresponding object field
+      #
+      # @param name [Symbol] the name of the field
+      # @param options [Hash] an optional hash of options.
+      #   Currently only the boolean option :attribute is avaiable (see {Mongoid::Giza::Index::Field#initialize})
+      # @param block [Proc] an optional block to be evaluated at the scope of the document on index creation
+      def field(name, options = {}, &block)
+        attribute = options[:attribute].nil? ? false : true
+        @fields << Mongoid::Giza::Index::Field.new(name, attribute, &block)
+      end
+
+      # Adds an attribute to the index with the corresponding name.
+      #
+      # If a type is not given then it will try to fetch the type of the corresponding class field,
+      # falling back to :string
+      #
+      # If a block is given then it will be evaluated for each instance of the class being indexed
+      # and the resulting value will be the attribute value.
+      # Otherwise the attribute value will be the value of the corresponding object field
+      #
+      # @param name [Symbol] the name of the attribute
+      # @param type [Symbol] an optional attribute type
+      # @param block [Proc] an optional block to be evaluated at the scope of the document on index creation
+      def attribute(name, type = nil, &block)
+        if type.nil?
+          field = @klass.fields[name.to_s]
+          type = field.nil? ? Mongoid::Giza::Index::TYPES_MAP.values.first :
+            Mongoid::Giza::Index::TYPES_MAP[field.type] || Mongoid::Giza::Index::TYPES_MAP.values.first
+        end
+        @attributes << Mongoid::Giza::Index::Attribute.new(name, type, &block)
+      end
+
+      # Retrieves and optionally sets the index name
+      #
+      # @param new_name [Symbol, String] an optional new name for the index
+      #
+      # @return [Symbol] The name of the index
+      def name(new_name = nil)
+        @name = new_name || @name.to_sym
+      end
+
+      def criteria(new_criteria = nil)
+        @criteria = new_criteria || @criteria
+      end
+
+      # Generates a XML document according to the XMLPipe2 specification from Sphinx
+      #
+      # @param buffer [#<<] any IO object that supports appending content using <<
+      def generate_xmlpipe2(buffer)
+        Mongoid::Giza::XMLPipe2.new(self, buffer).generate!
+      end
+    end
+  end
+end

data/lib/mongoid/giza/index/attribute.rb

@@ -0,0 +1,39 @@
+module Mongoid
+  module Giza
+    class Index
+
+      # Represents an Sphinx index {http://sphinxsearch.com/docs/current.html#attributes attribute}
+      class Attribute
+
+        # Defines the array of currently supported Sphix attribute types
+        TYPES = [
+          :uint, :bool, :bigint, :timestamp, :str2ordinal,
+          :float, :multi, :string, :json, :str2wordcount
+        ]
+
+        attr_accessor :name, :type, :block
+
+        # Creates a new attribute with name, type and an optional block
+        #
+        # If a block is given then it will be evaluated for each instance of the class being indexed
+        # and the resulting value will be the attribute value.
+        # Otherwise the attribute value will be the value of the corresponding object field
+        #
+        # @param name [Symbol] the name of the attribute
+        # @param type [Symbol] the type of the attribute. Must be one of the types defined in {Mongoid::Giza::Index::Attribute::TYPES}
+        # @param block [Proc] an optional block to be evaluated at the scope of the document on index creation
+        #
+        # @raise [TypeError] if the type is not valid. (see {Mongoid::Giza::Index::Attribute::TYPES})
+        def initialize(name, type, &block)
+          raise TypeError,
+            "attribute type not supported. " \
+            "It must be one of the following: " \
+            "#{Mongoid::Giza::Index::Attribute::TYPES.join(", ")}" unless Mongoid::Giza::Index::Attribute::TYPES.include? type
+          @name = name
+          @type = type
+          @block = block
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/giza/index/field.rb

@@ -0,0 +1,27 @@
+module Mongoid
+  module Giza
+    class Index
+
+      # Represents a Sphinx index {http://sphinxsearch.com/docs/current.html#fields full-text field}
+      class Field
+        attr_accessor :name, :attribute, :block
+
+        # Creates a full-text field with a name and an optional block
+        #
+        # If a block is given then it will be evaluated for each instance of the class being indexed
+        # and the resulting string will be the field value.
+        # Otherwise the field value will be the value of the corresponding object field
+        #
+        # @param name [Symbol] the name of the field
+        # @param attribute [TrueClass, FalseClass] whether this field will also be stored as an string attribute
+        #   (see {http://sphinxsearch.com/docs/current.html#conf-xmlpipe-field-string})
+        # @param block [Proc] an optional block to be evaluated at the scope of the document on index creation
+        def initialize(name, attribute = false, &block)
+          @name = name
+          @attribute = attribute
+          @block = block
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/giza/indexer.rb

@@ -0,0 +1,33 @@
+module Mongoid
+  module Giza
+
+    # Routines related to creating the defined indexes in sphinx
+    class Indexer
+      include Singleton
+
+      # Creates the Indexer instance
+      def initialize
+        @configuration = Mongoid::Giza::Configuration.instance
+        @controller = Riddle::Controller.new(@configuration, @configuration.file.output_path)
+      end
+
+      # Index everything, regenerating all dynamic indexes from all classes
+      def full_index
+        @configuration.clear_generated_indexes
+        giza_classes.each { |klass| klass.regenerate_dynamic_sphinx_indexes }
+        index!
+      end
+
+      # Creates the sphinx configuration file then executes the indexer on it
+      def index!(*indexes)
+        @configuration.render
+        @controller.index(*indexes, verbose: true)
+      end
+
+      # @return [Array<Class>] all Mongoid models that include the {Mongoid::Giza} module
+      def giza_classes
+        Mongoid.models.select { |model| model.include?(Mongoid::Giza) }
+      end
+    end
+  end
+end

data/lib/mongoid/giza/models/giza_id.rb

@@ -0,0 +1,27 @@
+module Mongoid
+  module Giza
+
+    # MongoDB counter collection to generate ids compatible with sphinx
+    class GizaID
+      include Mongoid::Document
+
+      field :_id, type: Symbol
+      field :seq, type: Integer, default: 0
+
+      attr_accessible :id
+
+      class << self
+
+        # Gets the next id in the sequence to assign to an object
+        #
+        # @param klass [Symbol] the name of the class which next id will be retrived for
+        #
+        # @return [Integer] the next id in the sequence
+        def next_id(klass)
+          giza_id = where(id: klass).find_and_modify({"$inc" => {seq: 1}}, new: true)
+          giza_id.seq
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/giza/railtie.rb

@@ -0,0 +1,17 @@
+require "rails"
+
+module Mongoid
+  module Giza
+    class Railtie < Rails::Railtie
+      configuration = Mongoid::Giza::Configuration.instance
+
+      initializer "mongoid-giza.load-configuration" do
+        # Sets the default xmlpipe_command
+        configuration.source.xmlpipe_command = "rails r '<%= index.klass %>.sphinx_indexes[:<%= index.name %>].generate_xmlpipe2(STDOUT)'"
+        # Loads the configuration file
+        file = Rails.root.join("config", "giza.yml")
+        configuration.load(file, Rails.env) if file.file?
+      end
+    end
+  end
+end

data/lib/mongoid/giza/search.rb

@@ -0,0 +1,83 @@
+module Mongoid
+  module Giza
+
+    # Executes queries on Sphinx
+    class Search
+      attr_accessor :indexes
+      attr_reader :client
+
+      # Creates a new search
+      #
+      # @param host [String] the host address of sphinxd
+      # @param port [Fixnum] the TCP port of sphinxd
+      # @param indexes [String] an optional string define the indexes that the search will run on.
+      #   Defaults to "*" which means all indexes
+      def initialize(host, port, *indexes)
+        @client = Riddle::Client.new(host, port)
+        @indexes = indexes
+      end
+
+      # Sets the search criteria on full-text fields
+      #
+      # @param query [String] a sphinx query string based on the current {http://sphinxsearch.com/docs/current.html#matching-modes matching mode}
+      def fulltext(query)
+        index = indexes.length > 0 ? indexes.join(" ") : "*"
+        @client.append_query(query, index)
+      end
+
+      # Sets a filter based on an attribute.
+      # Only documents that the attribute value matches will be returned from the search
+      #
+      # @param attribute [Symbol] the attribute name to set the filter
+      # @param value [Fixnum, Float, Range] the value (or values) that the attribute must match
+      def with(attribute, value)
+        @client.filters << Riddle::Client::Filter.new(attribute.to_s, value, false)
+      end
+
+      # Excludes from the search documents that the attribute value matches
+      #
+      # @param attribute [Symbol] the attribute name
+      # @param value [Fixnum, Float, Range] the value (or values) that the attribute must match
+      def without(attribute, value)
+        @client.filters << Riddle::Client::Filter.new(attribute.to_s, value, true)
+      end
+
+      # Sets the order in which the results will be returned
+      #
+      # @param attribute [Symbol] the attribute used for sorting
+      # @param order [Symbol] the order of the sorting. Valid values are :asc and :desc
+      def order_by(attribute, order)
+        @client.sort_by = "#{attribute} #{order.to_s.upcase}"
+      end
+
+      # Executes the configured queries
+      #
+      # @return [Array] an Array of Hashes as specified by Riddle::Response
+      def run
+        @client.run
+      end
+
+      # Checks for methods on Riddle::Client
+      #
+      # @param method [Symbol, String] the method name that will be checked on Riddle::Client
+      #
+      # @return [TrueClass, FalseClass] true if either Riddle::Client or Mongoid::Giza::Search respond to the method
+      def respond_to?(method)
+        @client.respond_to?("#{method}=") || super
+      end
+
+      # Dynamically dispatches the method call to Riddle::Client if the method is defined in it
+      #
+      # @param method [Symbol, String] the method name that will be called on Riddle::Client
+      # @param args [Array] an argument list that will also be forwarded to the Riddle::Client method
+      #
+      # @return [Object] the return value of the Riddle::Client method
+      #
+      # @raise [NoMethodError] if the method is also missing on Riddle::Client
+      def method_missing(method, *args)
+        super if !respond_to?(method)
+        @client.send "#{method}=", *args
+      end
+    end
+  end
+end

data/lib/mongoid/giza/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module Giza
+    VERSION = "0.1.0"
+  end
+end

data/lib/mongoid/giza/xml_pipe2.rb

@@ -0,0 +1,67 @@
+require "builder"
+
+module Mongoid
+  module Giza
+    class XMLPipe2
+
+      # Creates a new XMLPipe2 object based on the specified index and that will write to the specified buffer.
+      # Note that the actual XML will be generated only when {#generate!} is called
+      #
+      # @param index [Mongoid::Giza::Index] the index which will be used to generate the data
+      # @param buffer any object that supports the method <<
+      def initialize(index, buffer)
+        @index = index
+        @xml = Builder::XmlMarkup.new(target: buffer)
+      end
+
+      # Generates a XML document with the {http://sphinxsearch.com/docs/current.html#xmlpipe2 xmlpipe2 specification}.
+      # The buffer passed on object creation will contain the XML
+      def generate!
+        @xml.instruct! :xml, version: "1.0", encoding: "utf-8"
+        @xml.sphinx :docset do
+          generate_schema
+          generate_docset
+        end
+      end
+
+      # Generates the schema part of the XML document.
+      # Used internally by {#generate!} so you should never need to call it directly
+      def generate_schema
+        @xml.sphinx :schema do |schema|
+          @index.fields.each do |field|
+            attrs = {name: field.name}
+            attrs[:attr] = :string if field.attribute
+            schema.sphinx :field, attrs
+          end
+          @index.attributes.each { |attribute| schema.sphinx :attr, name: attribute.name, type: attribute.type }
+        end
+      end
+
+      # Generates the content part of the XML document.
+      # Used internally by {#generate!} so you should never need to call it directly
+      def generate_docset
+        @index.criteria.each do |object|
+          @xml.sphinx :document, id: object.giza_id do
+            generate_doc_tags(@index.fields, object)
+            generate_doc_tags(@index.attributes, object)
+          end
+        end
+      end
+
+      # Generates the tags with the content to be indexed of every field or attribute.
+      # Used internally by {#generate_docset} so you should never need to call it directly
+      #
+      # @param contents [Array] list of fields or attributes to generate the tags for
+      # @param object [Object] the object being indexed
+      def generate_doc_tags(contents, object)
+        contents.each do |content|
+          if content.block.nil?
+            @xml.tag! content.name, object[content.name]
+          else
+            @xml.tag! content.name, content.block.call(object)
+          end
+        end
+      end
+    end
+  end
+end