mongoid-giza 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d368cbce54de65a25b4965b2e25ee101f4fd0a99
-  data.tar.gz: cdb575b3810acb882ca135583cb3c2231d4d068d
+  metadata.gz: e68c24c85a8ab1a5058c90204c1b4b48c8894717
+  data.tar.gz: 23a10d3f8db970eef859cb5b4675f15c42cdf4c7
 SHA512:
-  metadata.gz: 66ec17363af5ff16a8563c9f797ddff95ec63b93794c6170e5b0cd487d1aeb208d983e9f4ca811eeeb0d68e986088a9bd74eb3a7245f5c346f54b202278b6c15
-  data.tar.gz: 8c8178f9cbe3b638da95b0712b1ffb08283b97ef1f2af6bcaa47b746cafc28ef84fb47de09da8edf0a08f7c1c6bdaf0a1a3d8defd2cbe456ee95ce38b630fe89
+  metadata.gz: 7ebbc8f78cae69b1eac182a59ceadbc9b1b3c6c43f968e190d75078a812fb939df5967ba59740df6ae6304ac12eb65f2332a8d308587d4b48fe820ccef609f8f
+  data.tar.gz: 08c98fb01da3de22b160cbebe2c8a7c69eee0124e26cfc2f5d8078d6e41f324cce8e52660c2644391570fd9742ca0195b6ca801d7b801145754608fb704bcfc9

data/.rubocop.yml

@@ -0,0 +1,10 @@
+Style/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+
+Style/Encoding:
+  Enabled: true
+  EnforcedStyle: when_needed
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+

data/.travis.yml

@@ -3,5 +3,6 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.1
+  - 2.2.1
 services:
   - mongodb

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.6.0
+
+* Mongoid 4 or higher is now required
+* Removed charset_type option, since it has been removed from spinx since 2.2.2-beta. You can still define it in your confuguration if you're using an older sphinx version
+* Renamed `Mongoid::Giza::GizaID` to `Mongoid::Giza::ID`
+* Renamed `Mongoid::Giza::ID::next_id to Mongoid::Giza::ID::next`
+* Renamed `giza_id` to `_giza_id`. Now it's a regular field instead of being dynamically assigned when needed
+* Support for `default` and `bits` for attributes
+* Removed *str2ordinal* and *str2wordcount* attribute types
+* Automatically convert Date, Time and DateTime attributes to unix time
+* Only support **ONE** fulltext query by *search block*. Instead of returning an Array o result Hashes now it only returns a result Hash
+
 ## 0.5.1
 
 * Create a sparse unique index on `giza_id` field

data/Gemfile

@@ -1,6 +1,6 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
-gem 'coveralls', require: false
+gem "coveralls", require: false
 
 # Specify your gem's dependencies in mongoid-giza.gemspec
 gemspec

data/README.md

@@ -168,7 +168,6 @@ Use the `search` block on the class that have the indexes where the search shoul
 It returns a result array, where each position of the array is a [riddle result hash](http://rdoc.info/github/pat/riddle/Riddle/Client#query-instance_method), plus a key with the class name, that has the `Mongoid::Criteria` that selects the matching objects from the mongo database.
 
 Inside the `search` block use the `fulltext` method to perform a fulltext search.
-If multiple `fulltext` are called inside a `search` block, then each one will generate a separated query and will return a new position o the results array.
 
 To filter your search using the attributes defined on the index creation, use the `with` and `without` methods, that accept the name of the attribute and the value or range.
 
@@ -179,13 +178,13 @@ Every other [Riddle::Client](http://rdoc.info/github/pat/riddle/Riddle/Client) s
 **Example:** Searching on the person class
 
 ```ruby
-results = Person.search do
+result = Person.search do
   fulltext "john"
   with :age 18..40
   order_by :age :asc
 end
 
-results.first[:Person].each do |person|
+result[:Person].each do |person|
  puts "#{person.name} is #{person.age} years old"
 end
 ```

data/Rakefile

@@ -3,9 +3,17 @@ Bundler.setup
 
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "rubocop/rake_task"
 
-RSpec::Core::RakeTask.new("spec") do |spec|
+RuboCop::RakeTask.new(:rubocop)
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = "spec/**/*_spec.rb"
 end
 
-task default: :spec
+task :build do
+  Rake::Task[:rubocop].invoke
+  Rake::Task[:spec].invoke
+end
+
+task default: :build

data/lib/mongoid/giza.rb

@@ -7,18 +7,18 @@ require "mongoid/giza/index"
 require "mongoid/giza/index/field"
 require "mongoid/giza/index/attribute"
 require "mongoid/giza/indexer"
-require "mongoid/giza/models/giza_id"
+require "mongoid/giza/models/id"
 require "mongoid/giza/railtie" if defined?(Rails)
 require "mongoid/giza/search"
 require "mongoid/giza/version"
 require "mongoid/giza/xml_pipe2"
 
 module Mongoid
-
   # Module that should be included in a Mongoid::Document in order to
-  # index fields of documents of this class
+  #   index fields of documents of this class
   #
-  # @example Creating a simple index with a full-text field (named fts) and an attribute (named attr)
+  # @example Creating a simple index with a full-text field (named fts) and an
+  #   attribute (named attr)
   #   class Person
   #     include Mongoid::Document
   #     include Mongoid::Giza
@@ -32,7 +32,8 @@ module Mongoid
   #     end
   #   end
   #
-  # @example Searching the previously defined index for people named John between 18 and 59 years old
+  # @example Searching the previously defined index for people named John
+  # between 18 and 59 years old
   #   results = Person.search do
   #     fulltext "john"
   #     with age: 18..59
@@ -43,57 +44,56 @@ module Mongoid
     extend ActiveSupport::Concern
 
     included do
-      Mongoid::Giza::GizaID.create(id: name.to_sym)
-      index({giza_id: 1}, {sparse: true, unique: true})
+      ID.create(id: name.to_sym) unless ID.where(id: name.to_sym).count == 1
+      field :_giza_id, type: Integer,
+                       default: -> { ID.next(self.class.name.to_sym) }
+      index({_giza_id: 1}, sparse: true, unique: true)
       @giza_configuration = Configuration.instance
       @static_sphinx_indexes = {}
       @generated_sphinx_indexes = {}
       @dynamic_sphinx_indexes = []
     end
 
-    # Retrives the sphinx compatible id of the object.
-    # If the id does not exists yet, it will be generated
-    #
-    # @return [Integer] the object's integer id generated by Giza
-    def giza_id
-      set(:giza_id, GizaID.next_id(self.class.name.to_sym)) if self[:giza_id].nil?
-      self[:giza_id]
-    end
-
     # Generates all the dynamic indexes defined on the class for the object
     def generate_sphinx_indexes
       self.class.dynamic_sphinx_indexes.each do |dynamic_index|
         index = dynamic_index.generate_index(self)
-        self.class.generated_sphinx_indexes.merge!({index.name => index})
+        self.class.generated_sphinx_indexes.merge!(index.name => index)
         self.class.giza_configuration.add_index(index, true)
       end
     end
 
+    # :nodoc:
     module ClassMethods
-      attr_reader :giza_configuration, :static_sphinx_indexes, :generated_sphinx_indexes, :dynamic_sphinx_indexes
+      attr_reader :giza_configuration, :static_sphinx_indexes,
+                  :generated_sphinx_indexes, :dynamic_sphinx_indexes
 
-      # Class method that defines a index relative to the current class' objects.
-      # If an argument is given in the block then a dynamic index will be created.
+      # Class method that defines a index relative to the current class objects.
+      # If an argument is given in the block then a dynamic index will be
+      #   created.
       # Otherwise it will create a static index.
       #
       # @param settings [Hash] optional settings for the index and it's source
-      # @param block [Proc] a block that will be evaluated on an {Mongoid::Giza::Index}
+      # @param block [Proc] a block that will be evaluated on an
+      #   {Mongoid::Giza::Index}
       def sphinx_index(settings = {}, &block)
-        if block_given?
-          if block.arity > 0
-            add_dynamic_sphinx_index(settings, block)
-          else
-            add_static_sphinx_index(settings, block)
-          end
+        return unless block_given?
+        if block.arity > 0
+          add_dynamic_sphinx_index(settings, block)
+        else
+          add_static_sphinx_index(settings, block)
         end
       end
 
       # Adds an dynamic index to the class.
-      # Will also automatically generate the dynamic index for each object of the class
+      # Will also automatically generate the dynamic index for each object of
+      #   the class
       #
       # @param settings [Hash] settings for the index and it's source
-      # @param block [Proc] a block that will be evaluated on an {Mongoid::Giza::Index}.
-      #   The block receives one argument that is the current object of the class for which the index will be generated
+      # @param block [Proc] a block that will be evaluated on an
+      #   {Mongoid::Giza::Index}.
+      #   The block receives one argument that is the current object of the
+      #   class for which the index will be generated
       def add_dynamic_sphinx_index(settings, block)
         dynamic_index = DynamicIndex.new(self, settings, block)
         dynamic_sphinx_indexes << dynamic_index
@@ -103,7 +103,8 @@ module Mongoid
       # Adds an static index to the class
       #
       # @param settings [Hash] settings for the index and it's source
-      # @param block [Proc] a block that will be evaluated on an {Mongoid::Giza::Index}.
+      # @param block [Proc] a block that will be evaluated on an
+      #   {Mongoid::Giza::Index}.
       def add_static_sphinx_index(settings, block)
         index = Index.new(self, settings)
         Docile.dsl_eval(index, &block)
@@ -114,66 +115,104 @@ module Mongoid
       # Generates the indexes from the dynamic index and
       # registers them on the class and on the configuration
       #
-      # @param dynamic_index [Mongoid::Giza::DynamicIndex] the dynamic index which will generate the static indexes from
+      # @param dynamic_index [Mongoid::Giza::DynamicIndex] the dynamic index
+      #   which will generate the static indexes from
       def process_dynamic_sphinx_index(dynamic_index)
         generated = dynamic_index.generate!
         generated_sphinx_indexes.merge!(generated)
-        generated.each { |name, index| giza_configuration.add_index(index, true) }
+        generated.each { |_, index| giza_configuration.add_index(index, true) }
       end
 
-      # Class method that implements a search DSL using a {Mongoid::Giza::Search} object.
-      # The search will run on indexes defined on the class unless it's overwritten using {Mongoid::Giza::Search#indexes=}
+      # Class method that implements a search DSL using a
+      #   {Mongoid::Giza::Search} object.
+      # The search will run on indexes defined on the class unless it's
+      #   overwritten using {Mongoid::Giza::Search#indexes=}
       #
-      # @param block [Proc] a block that will be evaluated on a {Mongoid::Giza::Search}
+      # @param block [Proc] a block that will be evaluated on a
+      #   {Mongoid::Giza::Search}
       #
-      # @return [Array] an Array with Riddle result hashes containing an additional key with the name of the class.
-      #   The value of this aditional key is a Mongoid::Criteria that return the actual objects of the match
+      # @return [Hash] a Riddle result Hash containing an
+      #   additional key with the name of the class.
+      #   The value of this aditional key is a Mongoid::Criteria that return the
+      #   actual objects of the match
       def search(&block)
-        search = Mongoid::Giza::Search.new(giza_configuration.searchd.address, giza_configuration.searchd.port, sphinx_indexes_names)
+        search = Search.new(giza_configuration.searchd.address,
+                            giza_configuration.searchd.port,
+                            sphinx_indexes_names)
         Docile.dsl_eval(search, &block)
-        results = search.run
-        results.each { |result| result[name.to_sym] = self.in(giza_id: result[:matches].map { |match| match[:doc] }) }
+        map_to_mongoid(search.run)
       end
 
       # Regenerates all dynamic indexes of the class
       def regenerate_sphinx_indexes
-        giza_configuration.remove_generated_indexes(generated_sphinx_indexes.keys)
+        giza_configuration
+          .remove_generated_indexes(generated_sphinx_indexes.keys)
         generated_sphinx_indexes.clear
-        dynamic_sphinx_indexes.each { |dynamic_index| process_dynamic_sphinx_index(dynamic_index) }
+        dynamic_sphinx_indexes.each do |dynamic_index|
+          process_dynamic_sphinx_index(dynamic_index)
+        end
       end
 
       # Removes the generated indexes.
       #
-      # @param names [Array] a list of generated index names that should be removed
+      # @param names [Array] a list of generated index names that should be
+      #   removed
       def remove_generated_sphinx_indexes(*names)
         names.each { |name| generated_sphinx_indexes.delete(name) }
         giza_configuration.remove_generated_indexes(names)
       end
 
       # Execute the indexing routines of the indexes defined on the class.
-      # This means (re)create the sphinx configuration file and then execute the indexer program on it.
-      # If no index names are supplied than all indexes defined on the class will be indexed.
-      # If none of the index names supplied are on this class then nothing is indexed
+      # This means (re)create the sphinx configuration file and then execute the
+      #   indexer program on it.
+      # If no index names are supplied than all indexes defined on the class
+      #   will be indexed.
+      # If none of the index names supplied are on this class then nothing is
+      #   indexed
       #
-      # @param names [Array] a list of index names of this class that will be indexed
+      # @param names [Array] a list of index names of this class that will be
+      #   indexed
       def sphinx_indexer!(*names)
-        indexes_names = names.length > 0 ? sphinx_indexes_names.select { |name| names.include? name } : sphinx_indexes_names
-        Mongoid::Giza::Indexer.instance.index!(*indexes_names) if indexes_names.length > 0
+        if names.length > 0
+          indexes_names =
+            sphinx_indexes_names.select { |name| names.include?(name) }
+        else
+          indexes_names = sphinx_indexes_names
+        end
+        Indexer.instance.index!(*indexes_names) if indexes_names.length > 0
       end
 
-      # Retrieves all the sphinx indexes defined on this class, static and dynamic
+      # Retrieves all the sphinx indexes defined on this class, static and
+      #   dynamic
       #
-      # @return [Hash] a Hash with indexes names as keys and the actual indexes as the values
+      # @return [Hash] a Hash with indexes names as keys and the actual indexes
+      #   as the values
       def sphinx_indexes
         static_sphinx_indexes.merge(generated_sphinx_indexes)
       end
 
-      # Retrieves all the names of sphinx indexes defined on this class, static and dynamic
+      # Retrieves all the names of sphinx indexes defined on this class, static
+      #   and dynamic
       #
-      # @return [Array] an Array of names of indexes from the current class {Mongoid::Giza::Index}
+      # @return [Array] an Array of names of indexes from the current class
+      #   {Mongoid::Giza::Index}
       def sphinx_indexes_names
         static_sphinx_indexes.merge(generated_sphinx_indexes).keys
       end
+
+      private
+
+      # Creates the Mongoid::Criteria that return the objects matched by the
+      #   sphinx search
+      #
+      # @param result [Hash] the query result created by Riddle
+      # @return [Hash] the result hash with the Mongoid::Criteria on the indexed
+      #   class' name key
+      def map_to_mongoid(result)
+        result[name.to_sym] =
+          self.in(_giza_id: result[:matches].map { |match| match[:doc] })
+        result
+      end
     end
   end
 end

data/lib/mongoid/giza/configuration.rb

@@ -4,7 +4,6 @@ require "yaml"
 
 module Mongoid
   module Giza
-
     # Holds the configuration of the module
     class Configuration < Riddle::Configuration
       include Singleton
@@ -24,16 +23,18 @@ module Mongoid
       # Loads a YAML file with settings defined.
       # Settings that are not recognized are ignored
       #
-      # @param path [String] path to the YAML file which contains the settings defined
+      # @param path [String] path to the YAML file which contains the settings
+      #   defined
       # @param env [String] environment whoose settings will be loaded
       def load(path, env)
         YAML.load(File.open(path).read)[env].each do |section_name, settings|
           section = instance_variable_get("@#{section_name}")
-          if !section.nil?
-            settings.each do |setting, value|
-              value = interpolate_string(value, nil) if section != @index and section != @source
-              setter(section, setting, value)
+          next unless section
+          settings.each do |setting, value|
+            unless section == @index || section == @source
+              value = interpolate_string(value, nil)
             end
+            setter(section, setting, value)
           end
         end
       end
@@ -41,21 +42,21 @@ module Mongoid
       # Adds an index to the sphinx configuration,
       # so this index can be rendered on the configuration file
       #
-      # @param index [Mongoid::Giza::Index] the index that will be added to the configuration
-      # @param generated [TrueClass, FalseClass] determines if this index was generated from a {Mongoid::Giza::DynamicIndex}
+      # @param index [Mongoid::Giza::Index] the index that will be added to the
+      #   configuration
+      # @param generated [TrueClass, FalseClass] determines if this index was
+      #   generated from a {Mongoid::Giza::DynamicIndex}
       def add_index(index, generated = false)
         riddle_index = create_index(index)
-        if generated
-          position = register_index(riddle_index, @generated_indexes)
-        else
-          position = register_index(riddle_index, @static_indexes)
-        end
+        indexes = generated ? @generated_indexes : @static_indexes
+        position = register_index(riddle_index, indexes)
         indices[position] = riddle_index
       end
 
       # Creates a new Riddle::Index based on the given {Mongoid::Giza::Index}
       #
-      # @param index [Mongoid::Giza::Index] the index to generate the configuration from
+      # @param index [Mongoid::Giza::Index] the index to generate the
+      #   configuration from
       #
       # @return [Riddle::Configuration::Index] the created riddle index
       def create_index(index)
@@ -66,39 +67,51 @@ module Mongoid
         apply_user_settings(index, riddle_index)
         apply_user_settings(index, source)
         riddle_index.path = File.join(riddle_index.path, index.name.to_s)
-        riddle_index.charset_type = "utf-8"
         riddle_index
       end
 
       # Adds the riddle index to it's respective collection
       #
-      # @param index [Riddle::Configuration::Index] the index that will be registrated
+      # @param riddle_index [Riddle::Configuration::Index] the index that will
+      #   be registrated
       # @param indexes [Hash] the collection which will hold this index
       #
-      # @return [Integer] the position where this index should be inserted on the configuration indices array
-      def register_index(index, indexes)
-        position = indexes.has_key?(index.name) ?  indices.index(indexes[index.name]) : indices.length
-        indexes[index.name] = index
+      # @return [Integer] the position where this index should be inserted on
+      #   the configuration indices array
+      def register_index(riddle_index, indexes)
+        position = indices.index(indexes[riddle_index.name]) || indices.length
+        indexes[riddle_index.name] = riddle_index
         position
       end
 
-      # Applies the settings defined on an object loaded from the configuration to a Riddle::Configuration::Index or Riddle::Configuration::XMLSource instance.
-      # Used internally by {#add_index} so you should never need to call it directly
+      # Applies the settings defined on an object loaded from the configuration
+      #   to a Riddle::Configuration::Index or Riddle::Configuration::XMLSource
+      #   instance.
+      # Used internally by {#add_index} so you should never need to call it
+      #   directly
       #
-      # @param default [Riddle::Configuration::Index, Riddle::Configuration::XMLSource] the object that holds the global settings values
-      # @param section [Riddle::Configuration::Index, Riddle::Configuration::XMLSource] the object that settings are being set
+      # @param default [Riddle::Configuration::Index,
+      #   Riddle::Configuration::XMLSource] the object that holds the global
+      #   settings values
+      # @param section [Riddle::Configuration::Index,
+      #   Riddle::Configuration::XMLSource] the object that settings are being
+      #   set
       def apply_default_settings(default, section, index)
         default.class.settings.each do |setting|
           value = interpolate_string(default.send("#{setting}"), index)
-          setter(section, setting, value) if !value.nil?
+          setter(section, setting, value) unless value.nil?
         end
       end
 
-      # Applies the settings defined on a {Mongoid::Giza::Index} to the Riddle::Configuration::Index or Riddle::Configuration::XMLSource.
-      # Used internally by {#add_index} so you should never need to call it directly
+      # Applies the settings defined on a {Mongoid::Giza::Index} to the
+      #   Riddle::Configuration::Index or Riddle::Configuration::XMLSource.
+      # Used internally by {#add_index} so you should never need to call it
+      #   directly
       #
-      # @param index [Mongoid::Giza::Index] the index where the settings were defined
-      # @param section [Riddle::Configuration::Index, Riddle::Configuration::XMLSource] where the settings will be applied
+      # @param index [Mongoid::Giza::Index] the index where the settings were
+      #   defined
+      # @param section [Riddle::Configuration::Index,
+      #   Riddle::Configuration::XMLSource] where the settings will be applied
       def apply_user_settings(index, section)
         index.settings.each do |setting, value|
           value = interpolate_string(value, index)
@@ -111,15 +124,17 @@ module Mongoid
         File.open(@file.output_path, "w") { |file| file.write(super) }
       end
 
-      # Removes all Riddle::Index from the indices Array that were created from a generated {Mongoid::Giza::Index}
+      # Removes all Riddle::Index from the indices Array that were created from
+      #   a generated {Mongoid::Giza::Index}
       def clear_generated_indexes
-        @generated_indexes.each { |name, index| indices.delete(index) }
+        @generated_indexes.each { |_, index| indices.delete(index) }
         @generated_indexes =  {}
       end
 
       # Removes Riddle::Index's specifieds as params
       #
-      # @param names [Array<Symbol>] names of generated indexes that should be removed
+      # @param names [Array<Symbol>] names of generated indexes that should be
+      #   removed
       def remove_generated_indexes(names)
         names.each do |name|
           indices.delete(@generated_indexes.delete(name))
@@ -128,22 +143,31 @@ module Mongoid
 
       # Interpolates a value if it's a String using ERB.
       # Useful for defining dynamic settings.
-      # The ERB template may reference to the current {Mongoid::Giza::Index} and it's methods
+      # The ERB template may reference to the current {Mongoid::Giza::Index} and
+      #   it's methods
       #
       # @param value [String] the ERB template that will be interpolated
-      # @param index [Mongoid::Giza::Index] the index that will be accessible from the template
+      # @param index [Mongoid::Giza::Index] the index that will be accessible
+      #   from the template
       #
-      # @return [Object] if value was a String and contains ERB syntax than it will beinterpolated and returned.
+      # @return [Object] if value was a String and contains ERB syntax than it
+      #   will beinterpolated and returned.
       #   Otherwise it will return the original value
       def interpolate_string(value, index)
         namespace = index.nil? ? Object.new : OpenStruct.new(index: index)
-        value.is_a?(String) ? ERB.new(value).result(namespace.instance_eval { binding }) : value
+        if value.is_a?(String)
+          return ERB.new(value).result(namespace.instance_eval { binding })
+        else
+          return value
+        end
       end
 
-      # Helper method to set a value to a setting from a section (i.e. indexer, source) if the section has this setting.
+      # Helper method to set a value to a setting from a section (i.e. indexer,
+      #   source) if the section has this setting.
       # If the setting is not avaiable on the section, nothing is done
       #
-      # @param section [Riddle::Configuration::Section] a configuration section to define the setting
+      # @param section [Riddle::Configuration::Section] a configuration section
+      #   to define the setting
       # @param setting [Symbol] the setting that will be defined on the section
       # @param value [Object] the value of the setting
       def setter(section, setting, value)