mongoid-giza 0.5.1 → 0.6.0

data/lib/mongoid/giza/dynamic_index.rb

@@ -1,16 +1,19 @@
 module Mongoid
   module Giza
-
-    # Defines a dynamic index which is used to generate a index for each object of the class
+    # 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}
+      # @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
+      # @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
@@ -21,29 +24,32 @@ module Mongoid
       # 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
+      # @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 = generate_index(object)
-          indexes[index.name] = index if !index.nil?
+          indexes[index.name] = index if index
         end
         indexes
       end
 
       # Generates the index for the object passed as parameter.
-      # It is only generated if the object's class is the class or a subclass of the index's class
+      # It is only generated if the object's class is the class or a subclass of
+      #   the index's class
       #
-      # @param object [Mongoid::Document] the object which the index block wil be evaluated for
+      # @param object [Mongoid::Document] the object which the index block wil
+      #   be evaluated for
       #
-      # @return [Mongoid::Giza::Index, NilClass] the resulting index from the evaluation
-      #   or nil if the object's class is not the index's class or a subclass of it
+      # @return [Mongoid::Giza::Index, NilClass] the resulting index from the
+      #   evaluation or nil if the object's class is not the index's class or a
+      #   subclass of it
       def generate_index(object)
-        if object.is_a?(klass)
-          index = Mongoid::Giza::Index.new(klass, settings)
-          Docile.dsl_eval(index, object, &block)
-        end
+        return unless object.is_a?(klass)
+        index = Mongoid::Giza::Index.new(klass, settings)
+        Docile.dsl_eval(index, object, &block)
       end
     end
   end

data/lib/mongoid/giza/index.rb

@@ -1,9 +1,7 @@
 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 = {
@@ -17,21 +15,24 @@ module Mongoid
         Time => :timestamp,
         BigDecimal => :float,
         Float => :float,
-        Array => :multi,
+        Array => :json,
         Range => :multi,
         Hash => :json,
-        Moped::BSON::ObjectId => :string,
-        ActiveSupport::TimeWithZone => :timestamp,
+        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.
+      # 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.
+      # 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
+      # @param settings [Hash] an optional settings hash to be forwarded to
+      #   Riddle
       def initialize(klass, settings = {})
         @klass = klass
         @settings = settings
@@ -43,38 +44,48 @@ module Mongoid
 
       # 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
+      # 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] options for the field.
-      # @option options [TrueClass, FalseClass] :attribute whether the field will also be a attribute or not (see {Mongoid::Giza::Index::Field#initialize})
-      # @param block [Proc] an optional block to be evaluated at the scope of the document on index creation
+      # @option options [TrueClass, FalseClass] :attribute whether the field
+      #   will also be a attribute or not (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)
+        attribute = options[:attribute]
+        @fields << 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 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
+      # 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?
+      # @param block [Proc] an optional block to be evaluated at the scope of
+      #   the document on index creation
+      def attribute(name, type = nil, options = {}, &block)
+        unless type
           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
+          if field
+            type = TYPES_MAP[field.type] || :string
+          else
+            type = :string
+          end
         end
-        @attributes << Mongoid::Giza::Index::Attribute.new(name, type, &block)
+        @attributes << Attribute.new(name, type, options, &block)
       end
 
       # Retrieves and optionally sets the index name
@@ -83,22 +94,25 @@ module Mongoid
       #
       # @return [Symbol] The name of the index
       def name(new_name = nil)
-        @name = new_name.to_sym if !new_name.nil?
+        @name = new_name.to_sym if new_name
         @name
       end
 
-      # Defines the Mongoid::Criteria that will be used to retrive objects when indexing.
+      # Defines the Mongoid::Criteria that will be used to retrive objects when
+      #   indexing.
       # Use this to filter what objects from the class will be indexed.
       # When an index is created the criteria is defined as class.all
       #
-      #@param new_criteria [Mongoid::Criteria] the criteria to be used
+      # @param new_criteria [Mongoid::Criteria] the criteria to be used
       def criteria(new_criteria = nil)
         @criteria = new_criteria || @criteria
       end
 
-      # Generates a XML document according to the XMLPipe2 specification from Sphinx
+      # Generates a XML document according to the XMLPipe2 specification from
+      #   Sphinx
       #
-      # @param buffer [#<<] any IO object that supports appending content using <<
+      # @param buffer [#<<] any IO object that supports appending content using
+      #   <<
       def xmlpipe2(buffer)
         Mongoid::Giza::XMLPipe2.new(self, buffer).generate!
       end

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

@@ -1,37 +1,42 @@
 module Mongoid
   module Giza
     class Index
-
-      # Represents an Sphinx index {http://sphinxsearch.com/docs/current.html#attributes attribute}
+      # Represents a Sphinx index attribute
       class Attribute
-
         # Defines the array of currently supported Sphix attribute types
         TYPES = [
-          :uint, :bool, :bigint, :timestamp, :str2ordinal,
-          :float, :multi, :string, :json, :str2wordcount
+          :uint, :bool, :bigint, :timestamp, :float,
+          :multi, :multi_64, :string, :json
         ]
 
-        attr_accessor :name, :type, :block
+        attr_accessor :name, :type, :default, :bits, :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
+        # 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
+        # @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
+        # @raise [TypeError] if the type is not valid. (see
+        #   {Mongoid::Giza::Index::Attribute::TYPES})
+        def initialize(name, type, options = {}, &block)
+          fail TypeError,
+               "Attribute type not supported. " \
+               "It must be one of the following: " \
+               "#{TYPES.join(', ')}" unless TYPES.include? type
           @name = name.to_s.mb_chars.downcase.to_sym
           @type = type
           @block = block
+          @default = options[:default]
+          @bits = options[:bits] if type == :uint
         end
       end
     end

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

@@ -1,22 +1,24 @@
 module Mongoid
   module Giza
     class Index
-
-      # Represents a Sphinx index {http://sphinxsearch.com/docs/current.html#fields full-text field}
+      # Represents a Sphinx indexed 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
+        # 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
+        # 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)
+        # @param attribute [TrueClass, FalseClass] whether this field will also
+        #   be stored as an string attribute
+        # @param block [Proc] an optional block to be evaluated at the scope of
+        #   the document on index creation
+        def initialize(name, attribute = nil, &block)
           @name = name.to_s.mb_chars.downcase.to_sym
           @attribute = attribute
           @block = block

data/lib/mongoid/giza/indexer.rb

@@ -1,6 +1,5 @@
 module Mongoid
   module Giza
-
     # Routines related to creating the defined indexes in sphinx
     class Indexer
       include Singleton
@@ -8,13 +7,14 @@ module Mongoid
       # Creates the Indexer instance
       def initialize
         @configuration = Mongoid::Giza::Configuration.instance
-        @controller = Riddle::Controller.new(@configuration, @configuration.file.output_path)
+        @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_sphinx_indexes }
+        giza_classes.each(&:regenerate_sphinx_indexes)
         @configuration.render
         index!
       end
@@ -23,13 +23,16 @@ module Mongoid
       #
       # @param names [Array<Symbol>] name of the indexes that should be indexed.
       #   If not provided all indexes from the configuration file are indexed
-      # @param options [Hash] additional options to pass to Riddle::Controller#index
-      # @option options [TrueClass, FalseClass] :verbose shows the indexer output
+      # @param options [Hash] additional options to pass to
+      #   Riddle::Controller#index
+      # @option options [TrueClass, FalseClass] :verbose shows the indexer
+      #   output
       def index!(*names)
         @controller.index(*names)
       end
 
-      # @return [Array<Class>] all Mongoid models that include the {Mongoid::Giza} module
+      # @return [Array<Class>] all Mongoid models that include the
+      #   {Mongoid::Giza} module
       def giza_classes
         Mongoid.models.select { |model| model.include?(Mongoid::Giza) }
       end

data/lib/mongoid/giza/models/{giza_id.rb → id.rb}

@@ -1,24 +1,22 @@
 module Mongoid
   module Giza
-
     # MongoDB counter collection to generate ids compatible with sphinx
-    class GizaID
+    class ID
       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
+        # @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)
+        def next(klass)
+          giza_id = where(id: klass).find_and_modify({"$inc" => {seq: 1}},
+                                                     new: true)
           giza_id.seq
         end
       end

data/lib/mongoid/giza/railtie.rb

@@ -2,15 +2,18 @@ require "rails"
 
 module Mongoid
   module Giza
+    # :nodoc:
     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 %>].xmlpipe2(STDOUT)'"
+        configuration.source.xmlpipe_command =
+          "rails r '<%= index.klass %>.sphinx_indexes[:<%= index.name %>]" \
+          ".xmlpipe2(STDOUT)'"
         # Loads the configuration file
-        file = Rails.root.join("config", "giza.yml")
-        configuration.load(file, Rails.env) if file.file?
+        giza_yml = Rails.root.join("config", "giza.yml")
+        configuration.load(giza_yml, Rails.env) if giza_yml.file?
       end
     end
   end

data/lib/mongoid/giza/search.rb

@@ -1,82 +1,96 @@
 module Mongoid
   module Giza
-
     # Executes queries on Sphinx
     class Search
-      attr_accessor :indexes
+      attr_accessor :indexes, :query_string
       attr_reader :client
 
+      alias_method :fulltext, :query_string=
+
       # Creates a new search
       #
       # @param host [String] the host address of sphinxd
       # @param port [Fixnum] the TCP port of sphinxd
-      # @param names [Array] an optional array defining the indexes that the search will run on.
+      # @param names [Array] an optional array defining the indexes that the
+      #   search will run on.
       #   Defaults to "[]" which means all indexes
       def initialize(host, port, names = [])
         @client = Riddle::Client.new(host, port)
         @indexes = names
       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
+      # 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
+      # @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)
+        @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
+      # @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)
+        @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
+      # @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
+      # Executes the configured query
       #
       # @return [Array] an Array of Hashes as specified by Riddle::Response
       def run
-        @client.run
+        index = indexes.length > 0 ? indexes.join(" ") : "*"
+        @client.query(query_string, index)
       end
 
       # Checks for methods on Riddle::Client
       #
-      # @param method [Symbol, String] the method name that will be checked 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
+      # @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
+        @client.respond_to?(method) ||
+          @client.respond_to?("#{method}=") ||
+          super
       end
 
-      # Dynamically dispatches the method call to Riddle::Client if the method is defined in it
+      # 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
+      # @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
+        if args.length == 1
+          method_writer = "#{method}="
+          super unless respond_to?(method_writer)
+          @client.send method_writer, *args
+        else
+          super unless respond_to?(method)
+          @client.send method, *args
+        end
       end
     end
   end