mongoid-giza 0.5.1 → 0.6.0

data/lib/mongoid/giza/version.rb

@@ -1,5 +1,6 @@
 module Mongoid
+  # :nodoc:
   module Giza
-    VERSION = "0.5.1"
+    VERSION = "0.6.0"
   end
 end

data/lib/mongoid/giza/xml_pipe2.rb

@@ -2,19 +2,24 @@ require "builder"
 
 module Mongoid
   module Giza
+    # Represents the xmlpipe2 data source
     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
+      # 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 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}.
+      # 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"
@@ -25,43 +30,84 @@ module Mongoid
       end
 
       # Generates the schema part of the XML document.
-      # Used internally by {#generate!} so you should never need to call it directly
+      # 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
+            schema.sphinx :field, field_attrs(field)
+          end
+          @index.attributes.each do |attribute|
+            schema.sphinx :attr, attribute_attrs(attribute)
           end
-          @index.attributes.each { |attribute| schema.sphinx :attr, name: attribute.name, type: attribute.type }
         end
       end
 
+      # Returns a Hash of the field's attributes
+      #
+      # @return [Hash] The field's attributes
+      def field_attrs(field)
+        attrs = {name: field.name}
+        attrs[:attr] = :string if field.attribute
+        attrs
+      end
+
+      # Returns a Hash of the attribute's attributes
+      #
+      # @return [Hash] The attribute's attributes
+      def attribute_attrs(attribute)
+        attrs = {name: attribute.name, type: attribute.type}
+        attrs[:default] = attribute.default if attribute.default
+        attrs[:bits] = attribute.bits if attribute.bits
+        attrs
+      end
+
       # Generates the content part of the XML document.
-      # Used internally by {#generate!} so you should never need to call it directly
+      # 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
+          @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
+      # Generates the tags with the content to be indexed of every field and
+      #   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 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
+          if content.block
             @xml.tag! content.name, content.block.call(object)
+          else
+            @xml.tag! content.name, process_value(content, object)
           end
         end
       end
+
+      # Process values
+      # * Converts Date, Time and DateTime objects to unix time
+      #
+      # @param content
+      #   [Mongoid::Giza::Index::Field, Mongoid::Giza::Index::Attribute] field
+      #   or attribute to process content
+      # @param object [Object] object being indexed
+      #
+      # @return the processed object attribute value
+      def process_value(content, object)
+        if content.is_a?(Index::Attribute) && content.type == :timestamp
+          return object[content.name].to_time.to_i
+        else
+          return object[content.name]
+        end
+      end
     end
   end
 end

data/mongoid-giza.gemspec

@@ -1,21 +1,22 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'mongoid/giza/version'
+require "mongoid/giza/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "mongoid-giza"
   spec.version       = Mongoid::Giza::VERSION
   spec.authors       = ["Maurício Batista"]
   spec.email         = ["eddloschi@gmail.com"]
-  spec.description   = %q{Mongoid layer for the Sphinx fulltext search server that supports block fields and dynamic indexes}
-  spec.summary       = %q{Mongoid layer for the Sphinx fulltext search server}
+  spec.description   = "Mongoid layer for the Sphinx fulltext search server " \
+                       "that supports block fields and dynamic indexes"
+  spec.summary       = %(Mongoid layer for the Sphinx fulltext search server)
   spec.homepage      = "https://github.com/yadevteam/mongoid-giza"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files         = `git ls-files`.split($RS)
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.3"
@@ -24,10 +25,11 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "mongoid-rspec", ">= 1.9"
   spec.add_development_dependency "yard", ">= 0.8.7"
   spec.add_development_dependency "database_cleaner", ">= 1.2.0"
+  spec.add_development_dependency "rubocop", ">= 0.29.0"
 
-  spec.add_runtime_dependency "mongoid", ">= 3.1"
-  spec.add_runtime_dependency "riddle", ">= 1.5"
+  spec.add_runtime_dependency "mongoid", ">= 4.0"
+  spec.add_runtime_dependency "riddle", ">= 1.5.11"
   spec.add_runtime_dependency "builder", ">= 3.0"
   spec.add_runtime_dependency "docile", ">= 1.1"
-  spec.add_runtime_dependency "activesupport"
+  spec.add_runtime_dependency "activesupport", ">= 4.0"
 end

data/spec/mongoid/giza/configuration_spec.rb

@@ -4,8 +4,10 @@ describe Mongoid::Giza::Configuration do
   before do
     @default_source = double("default_source")
     @default_index = double("default_index")
-    allow(Riddle::Configuration::XMLSource).to receive(:new).with(:source, :xmlpipe2) { @default_source }
-    allow(Riddle::Configuration::Index).to receive(:new).with(:index, @default_source) { @default_index }
+    allow(Riddle::Configuration::XMLSource).to receive(:new)
+      .with(:source, :xmlpipe2) { @default_source }
+    allow(Riddle::Configuration::Index).to receive(:new)
+      .with(:index, @default_source) { @default_index }
     @config = Mongoid::Giza::Configuration.send(:new)
   end
 
@@ -14,7 +16,8 @@ describe Mongoid::Giza::Configuration do
       expect(@config.index).to be(@default_index)
     end
 
-    it "should create a Riddle::Configuration::XMLSource for default settings" do
+    it "should create a Riddle::Configuration::XMLSource for default " \
+      "settings" do
       expect(@config.source).to be(@default_source)
     end
 
@@ -35,33 +38,44 @@ describe Mongoid::Giza::Configuration do
     let(:file_open) { allow(File).to receive(:open).with("giza.yml") { file } }
 
     it "should load the configuration file" do
-      expect(file).to receive(:read) { "test:\n  searchd:\n    address: localhost" }
+      expect(file).to receive(:read) do
+        "test:\n  searchd:\n    address: localhost"
+      end
       expect(File).to receive(:open).with("giza.yml") { file }
       @config.load("giza.yml", "test")
     end
 
     it "should set settings" do
-      allow(file).to receive(:read) { "test:\n  searchd:\n    address: localhost" }
+      allow(file).to receive(:read) do
+        "test:\n  searchd:\n    address: localhost"
+      end
       file_open
       @config.load("giza.yml", "test")
       expect(@config.searchd.address).to eql("localhost")
     end
 
     it "should ignore non-existent sections" do
-      allow(file).to receive(:read) { "test:\n  miss_section:\n    address: localhost" }
+      allow(file).to receive(:read) do
+        "test:\n  miss_section:\n    address: localhost"
+      end
       file_open
       expect { @config.load("giza.yml", "test") }.not_to raise_error
     end
 
     it "should ignore non-existent settings" do
-      allow(file).to receive(:read) { "test:\n  searchd:\n    miss_setting: false" }
-      expect(@config.searchd).not_to receive(:method_missing).with(:miss_setting=, false)
+      allow(file).to receive(:read) do
+        "test:\n  searchd:\n    miss_setting: false"
+      end
+      expect(@config.searchd).not_to receive(:method_missing)
+        .with(:miss_setting=, false)
       file_open
       @config.load("giza.yml", "test")
     end
 
     it "should interpolate the string with ERB" do
-      allow(file).to receive(:read) { "test:\n  searchd:\n    address: localhost" }
+      allow(file).to receive(:read) do
+        "test:\n  searchd:\n    address: localhost"
+      end
       expect(@config).to receive(:interpolate_string).with("localhost", nil)
       file_open
       @config.load("giza.yml", "test")
@@ -75,7 +89,9 @@ describe Mongoid::Giza::Configuration do
     end
 
     it "should not interpolate source settings" do
-      allow(file).to receive(:read) { "test:\n  source:\n    xmlpipe_command: cmd" }
+      allow(file).to receive(:read) do
+        "test:\n  source:\n    xmlpipe_command: cmd"
+      end
       expect(@config).not_to receive(:interpolate_string)
       file_open
       @config.load("giza.yml", "test")
@@ -142,14 +158,18 @@ describe Mongoid::Giza::Configuration do
     before do
       allow(Riddle::Configuration::Index).to receive(:settings) { [] }
       allow(Riddle::Configuration::XMLSource).to receive(:new) { source }
-      allow(Riddle::Configuration::Index).to receive(:new).with(index.name, source) { riddle_index }
+      allow(Riddle::Configuration::Index).to receive(:new)
+        .with(index.name, source) { riddle_index }
       allow(@config).to receive(:apply_default_settings)
       allow(@config).to receive(:apply_user_settings)
     end
 
     it "should create a xmlpipe2 source with the same name of the index" do
-      expect(Riddle::Configuration::XMLSource).to receive(:new).with(index.name, :xmlpipe2) { source }
-      allow(Riddle::Configuration::Index).to receive(:new) { double("riddle_index").as_null_object }
+      expect(Riddle::Configuration::XMLSource).to receive(:new)
+        .with(index.name, :xmlpipe2) { source }
+      allow(Riddle::Configuration::Index).to receive(:new) do
+        double("riddle_index").as_null_object
+      end
       @config.create_index(index)
     end
 
@@ -158,17 +178,20 @@ describe Mongoid::Giza::Configuration do
       allow(@default_index).to receive(:path) { "/path/to/index" }
       allow(riddle_index).to receive(:path=).with("/path/to/index")
       allow(riddle_index).to receive(:path) { "/path/to/index" }
-      expect(riddle_index).to receive(:path=).with("/path/to/index/#{index.name}")
+      expect(riddle_index).to receive(:path=)
+        .with("/path/to/index/#{index.name}")
       @config.create_index(index)
     end
 
     it "should apply default settings to the index" do
-      expect(@config).to receive(:apply_default_settings).with(@default_index, riddle_index, index)
+      expect(@config).to receive(:apply_default_settings)
+        .with(@default_index, riddle_index, index)
       @config.create_index(index)
     end
 
     it "should apply default settings to the source" do
-      expect(@config).to receive(:apply_default_settings).with(@default_source, source, index)
+      expect(@config).to receive(:apply_default_settings)
+        .with(@default_source, source, index)
       @config.create_index(index)
     end
 
@@ -188,38 +211,30 @@ describe Mongoid::Giza::Configuration do
   end
 
   describe "register_index" do
-    let(:indices) { double("indices") }
-
-    let(:length) { double("length") }
-
-    let(:index) { double("index") }
-
-    let(:indexes) { double("indexes") }
+    let(:riddle_index) do
+      instance_double("Riddle::Configuration::Index", name: "name")
+    end
 
-    before do
-      allow(@config).to receive(:indices) { indices }
-      allow(indices).to receive(:length) { length }
-      allow(index).to receive(:name) { :index }
-      allow(indexes).to receive(:[]=)
-      allow(indexes).to receive(:has_key?)
+    let(:riddle_index_copy) do
+      instance_double("Riddle::Configuration::Index", name: "name")
     end
 
+    let(:indexes) { {riddle_index.name => riddle_index} }
+
     it "should add the index to the given hash" do
-      expect(indexes).to receive(:[]=).with(:index, index)
-      @config.register_index(index, indexes)
+      @config.register_index(riddle_index, indexes)
+      expect(indexes).to include riddle_index.name => riddle_index
     end
 
-    it "should return the position to replace the index on the configuration indices" do
-      position = double("position")
-      allow(indexes).to receive(:has_key?).with(:index) { true }
-      allow(indexes).to receive(:[]).with(:index) { index }
-      allow(indices).to receive(:index).with(index) { position }
-      expect(@config.register_index(index, indexes)).to be(position)
+    it "should return the position of the index in the indices array" do
+      @config.indices.push(riddle_index)
+      position = @config.register_index(riddle_index_copy, indexes)
+      expect(position).to eql 0
     end
 
-    it "should return the position to add the index on the configuration indices" do
-      allow(indexes).to receive(:has_key?).with(:index) { false }
-      expect(@config.register_index(index, indexes)).to be(length)
+    it "should return the indices array length if it's not on the array" do
+      position = @config.register_index(riddle_index, indexes)
+      expect(position).to eql @config.indices.length
     end
   end
 
@@ -317,8 +332,9 @@ describe Mongoid::Giza::Configuration do
       allow(@config.indexer).to receive(:render) { "indexer" }
       allow(@config.searchd).to receive(:render) { "searchd" }
       allow(index).to receive(:render) { "source\nindex" }
-      expect(File).to receive(:open).with(@config.file.output_path, "w").and_yield(file)
-      expect(file).to receive(:write).with("indexer\nsearchd\nsource\nindex")
+      expect(File).to receive(:open).with(@config.file.output_path, "w")
+        .and_yield(file)
+      expect(file).to receive(:write).with("\nindexer\nsearchd\nsource\nindex")
       @config.render
     end
   end
@@ -327,7 +343,7 @@ describe Mongoid::Giza::Configuration do
     let(:indices) { double("indices") }
 
     before do
-      @config.instance_variable_set("@generated_indexes", {name: :index})
+      @config.instance_variable_set("@generated_indexes", name: :index)
     end
 
     it "should delete the generated riddle indexes" do
@@ -356,7 +372,8 @@ describe Mongoid::Giza::Configuration do
       @config.setter(section, :setting, value)
     end
 
-    it "should no set the value if the section does not respond to the attribute setter" do
+    it "should no set the value if the section does not respond to the " \
+      "attribute setter" do
       allow(section).to receive(:respond_to?).with("setting=") { false }
       expect(section).not_to receive("setting=")
       @config.setter(section, :setting, value)
@@ -367,7 +384,8 @@ describe Mongoid::Giza::Configuration do
     let(:indices) { double("indices")  }
 
     before do
-      @config.instance_variable_set("@generated_indexes", {name: :index, two: :index2})
+      @config.instance_variable_set("@generated_indexes", name: :index,
+                                                          two: :index2)
     end
 
     it "should remove the indexes from the indices array" do
@@ -378,7 +396,8 @@ describe Mongoid::Giza::Configuration do
 
     it "should remove the index from the generated indexes collection" do
       @config.remove_generated_indexes([:name])
-      expect(@config.instance_variable_get("@generated_indexes")).not_to include(name: :index)
+      expect(@config.instance_variable_get("@generated_indexes"))
+        .not_to include(name: :index)
     end
   end
 end

data/spec/mongoid/giza/dynamic_index_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 describe Mongoid::Giza::DynamicIndex do
   describe "initialize" do
     it "should accept the class,  settings and a proc" do
-      dynamic_index = Mongoid::Giza::DynamicIndex.new(Object, {}, Proc.new { })
+      dynamic_index = Mongoid::Giza::DynamicIndex.new(Object, {}, -> {})
       expect(dynamic_index.klass).to be(Object)
       expect(dynamic_index.settings).to eql({})
       expect(dynamic_index.block).to be_a_kind_of(Proc)
@@ -11,7 +11,7 @@ describe Mongoid::Giza::DynamicIndex do
   end
 
   describe "generate!" do
-    let(:dynamic_index) { Mongoid::Giza::DynamicIndex.new(Object, {}, Proc.new { }) }
+    let(:dynamic_index) { Mongoid::Giza::DynamicIndex.new(Object, {}, -> {}) }
 
     let(:index) { double("index") }
 
@@ -51,19 +51,21 @@ describe Mongoid::Giza::DynamicIndex do
     end
 
     it "should check if the object is from the index's class" do
-      expect(Mongoid::Giza::DynamicIndex.new(String, {}, Proc.new { }).generate_index(Array.new)).to eql(nil)
+      expect(Mongoid::Giza::DynamicIndex.new(String, {}, -> {})
+          .generate_index([])).to eql(nil)
     end
 
     it "should execute the index dsl on the parameter" do
       object = Object.new
-      block = Proc.new { }
+      block = proc {}
       expect(Docile).to receive(:dsl_eval).with(index, object, &block)
       Mongoid::Giza::DynamicIndex.new(Object, {}, block).generate_index(object)
     end
 
     it "should return an Index" do
       allow(Docile).to receive(:dsl_eval) { index }
-      expect(Mongoid::Giza::DynamicIndex.new(String, {}, Proc.new { }).generate_index("")).to be(index)
+      expect(Mongoid::Giza::DynamicIndex.new(String, {}, -> {})
+        .generate_index("")).to be(index)
     end
   end
 end