dnif 0.0.1.beta.3 → 0.0.1.beta.4

data/lib/dnif/document.rb

@@ -13,7 +13,7 @@ module Dnif
           (index.fields - fields).each do |name|
             if @object.index.fields.include?(name)
               xml.tag!(name) do
-                xml.cdata!(@object.send(name))
+                xml.cdata!(@object.send(name).to_s)
               end
             else
               xml.tag!(name, "")
@@ -52,14 +52,14 @@ module Dnif
       xml.target!
     end
 
-    private
-
-    def encoded_class_name
-      @encoded_class_name ||= Dnif::MultiAttribute.encode(@object.class.name)
-    end
-
     def document_id
       @object.id + encoded_class_name.split(',').sum { |c| c.to_i }
     end
+
+    private
+
+      def encoded_class_name
+        @encoded_class_name ||= Dnif::MultiAttribute.encode(@object.class.name)
+      end
   end
-end
+end

data/lib/dnif/indexer.rb

@@ -48,5 +48,3 @@ module Dnif
     end
   end
 end
-
-ActiveRecord::Base.extend(Dnif::Indexer) if defined?(ActiveRecord::Base)

data/lib/dnif/schema.rb

@@ -42,7 +42,7 @@ module Dnif
         "timestamp"
       when :boolean
         "bool"
-      when :float
+      when :float, :decimal
         "float"
       end
     end

data/lib/dnif/search.rb

@@ -1,58 +1,9 @@
 module Dnif
 
-  def self.search(query, options = {})
-    options.reverse_merge!(:index => '*')
-
-    if options[:classes]
-      ids = if options[:classes].is_a?(Array)
-        options[:classes].map { |name| ActiveRecord::Base.indexes.keys.index(name) }
-      else
-        [ActiveRecord::Base.indexes.keys.index(options[:classes])]
-      end
-
-      client.filters = [Riddle::Client::Filter.new("class_id", ids)]
-    end
-
-    results = client.query(query, options[:index])
-    raise results[:error] if results[:error]
-
-    models = results[:matches].inject({}) do |memo, match|
-      encoded_class_name = match[:attributes]["class_name"].split(',').flatten
-      class_name = Dnif::MultiAttribute.decode(encoded_class_name)
-
-      memo[class_name] ||= []
-      memo[class_name] << (match[:doc] - encoded_class_name.sum { |c| c.to_i })
-      memo
-    end
-
-    models.map do |class_name, ids|
-      class_name.constantize.find_all_by_id(ids)
-    end.flatten
-  end
-
-  def self.client
-    searchd = Dnif::Configuration.options_for("searchd", config_path)
-    if searchd["listen"]
-      address, port = searchd["listen"].split(":")
-    else
-      address = searchd["address"] || "127.0.0.1"
-      port = searchd["port"] || 3313
-    end
-
-    @client ||= Riddle::Client.new(address, port)
-  end
-
-  def self.config_path
-    Dnif.root_path ||= File.expand_path(File.dirname("."))
-    File.join(Dnif.root_path, "config/sphinx", Dnif.environment + ".erb")
-  end
-
   module Search
 
     def search(query)
       Dnif.search(query, :classes => self.name)
     end
   end
-end
-
-ActiveRecord::Base.extend(Dnif::Search) if defined?(ActiveRecord::Base)
+end

data/lib/dnif/tasks.rb

@@ -1,6 +1,11 @@
-require 'active_support'
-require 'fileutils'
-require 'dnif'
+require "riddle"
+require "fileutils"
+
+if defined?(Rails)
+  Dnif.root_path = Rails.root
+  Dnif.environment = Rails.env
+  Dnif.models_path = File.join(Rails.root, "app", "models")
+end
 
 def controller
   require 'riddle'
@@ -17,12 +22,6 @@ end
 
 namespace :dnif do
 
-  task :environment do
-    if task = Rake::Task[:environment]
-      task.invoke
-    end
-  end
-
   desc "Generates the configuration file needed for sphinx"
   task :configure => :environment do
     if Dnif.models_path.nil?
@@ -40,11 +39,12 @@ namespace :dnif do
 
     base_path = File.join(config_path, Dnif.environment + ".erb")
     if not File.exist?(base_path)
-      FileUtils.cp(File.dirname(__FILE__) + "/../../test/fixtures/templates/config.erb", base_path) # TODO change this path. find out how this kind of stuff is handle in others gems
+      FileUtils.cp(File.dirname(__FILE__) + "/../../templates/config.erb", base_path) # TODO change this path. find out how this kind of stuff is handle in others gems
     end
 
     Dnif.load_models
-    Dnif::Configuration.generate(base_path)
+    path = Dnif::Configuration.generate(base_path)
+    puts "Config file generated: #{path}"
   end
 
   desc "Generates the XML used by sphinx to create indexes"

data/lib/dnif/version.rb

@@ -0,0 +1,10 @@
+module Dnif
+  module Version
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 1
+    BUILD = "beta.4"
+
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
+  end
+end

data/spec/dnif/configuration_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'erb'
+
+describe Dnif::Configuration do
+
+  it "should generate configuration from default template" do
+    File.should_receive(:read).with("config/path.erb").and_return("configurations")
+
+    template = mock("Template")
+    template.should_receive(:result).and_return('output')
+    ERB.should_receive(:new).with("configurations").and_return(template)
+
+    file = mock
+    file.should_receive(:puts).with('output')
+    File.should_receive(:open).with(Dnif.root_path + "/config/sphinx/development.conf", "w").and_yield(file)
+
+    path = Dnif::Configuration.generate("config/path.erb")
+    path.should == File.join(Dnif.root_path, "config", "sphinx", "development.conf")
+  end
+
+  describe "helpers" do
+
+    it "should iterate over all indexed classes" do
+      names = []
+      classes = []
+      Dnif::Configuration.sources do |name, class_name|
+        names << name
+        classes << class_name
+      end
+
+      names.should == ["users_main", "people_main", "orders_main", "notes_main"]
+      classes.should == ["User", "Person", "Order", "Note"]
+    end
+  end
+
+  it ".options_for" do
+    client = Dnif::Configuration.options_for("searchd", File.join(Dnif.root_path, "templates", "config.erb"))
+    client.should be_kind_of(Hash)
+  end
+end

data/spec/dnif/dnif_spec.rb

@@ -0,0 +1,157 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Dnif do
+
+  after(:each) do
+    Dnif.instance_variable_set(:"@root_path", nil)
+    Dnif.instance_variable_set(:"@environment", nil)
+    Dnif.instance_variable_set(:"@models_path", nil)
+  end
+
+  it ".root_path" do
+    Dnif.root_path = "/root/path"
+    Dnif.root_path.should == "/root/path"
+  end
+
+  it ".environment" do
+    Dnif.environment.should == "development"
+
+    Dnif.environment = "production"
+    Dnif.environment.should == "production"
+  end
+
+  it "should have .environment aliased by .env" do
+    Dnif.env.should == "development"
+
+    Dnif.env = "production"
+    Dnif.env.should == "production"
+  end
+
+  it ".models_path" do
+    Dnif.models_path = "/models/path"
+    Dnif.models_path.should == "/models/path"
+  end
+
+  describe ".client" do
+
+    it "should understand 'listen' sphinx setting" do
+      Dnif.should_receive(:config_path).and_return("config/path.erb")
+      Dnif::Configuration.should_receive(:options_for).with("searchd", "config/path.erb").and_return({ "listen" => "127.0.0.1:3313" })
+      Riddle::Client.should_receive(:new).with("127.0.0.1", "3313")
+
+      Dnif.client
+    end
+
+    it "should understand 'address' and 'port' sphinx setting" do
+      Dnif.should_receive(:config_path).and_return("config/path.erb")
+      Dnif::Configuration.should_receive(:options_for).with("searchd", "config/path.erb").and_return({ "address" => "127.0.0.1", "port" => "3313" })
+      Riddle::Client.should_receive(:new).with("127.0.0.1", "3313")
+
+      Dnif.client
+    end
+  end
+
+  describe ".search" do
+
+    it "should search for all models" do
+      results = {
+        :matches => [{
+                       :doc => 2983,
+                       :attributes => {
+                         "class_name" => "336,623,883,1140"
+                       }
+                     }, {
+                       :doc => 7893,
+                       :attributes => {
+                         "class_name" => "323,623,877,1133,1381,1646,1908"
+                       }
+        }]
+      }
+
+      riddle = mock("Riddle")
+      riddle.should_receive(:query).with("my search", "*").and_return(results)
+      Dnif.should_receive(:client).and_return(riddle)
+      Post.should_receive(:find_all_by_id).once.with([1])
+      Comment.should_receive(:find_all_by_id).once.with([2])
+
+      Dnif.search("my search")
+    end
+
+    it "should search specific models" do
+      riddle = mock("Riddle")
+      riddle.should_receive(:query).with("post", "*").and_return(results_for_post)
+      riddle.should_receive(:query).with("comment", "*").and_return(results_for_comment)
+      riddle.should_receive(:filters=).twice.and_return([])
+      Dnif.should_receive(:client).exactly(4).times.and_return(riddle)
+
+      ActiveRecord::Base.should_receive(:indexes).twice.and_return({ "Post" => mock, "Comment" => mock })
+
+      Riddle::Client::Filter.should_receive(:new).with("class_id", [0])
+      Riddle::Client::Filter.should_receive(:new).with("class_id", [1])
+
+      Post.should_receive(:find_all_by_id).once.with([1])
+      Comment.should_receive(:find_all_by_id).once.with([2])
+
+      Post.search("post")
+      Comment.search("comment")
+    end
+
+    it "should search only specified models" do
+      riddle = mock("Riddle")
+      riddle.should_receive(:query).with("post", "*").and_return(results_for_post)
+      riddle.should_receive(:filters=).and_return([])
+      Dnif.should_receive(:client).exactly(2).times.and_return(riddle)
+
+      ActiveRecord::Base.should_receive(:indexes).and_return({ "Post" => mock })
+
+      Riddle::Client::Filter.should_receive(:new).with("class_id", [0])
+      Post.should_receive(:find_all_by_id).once.with([1])
+
+      Dnif.search("post", :classes => "Post")
+    end
+  end
+
+  describe ".config_path" do
+
+    it "should return '.' when not specified" do
+      File.should_receive(:expand_path).and_return("/expanded/path")
+      Dnif.should_receive(:root_path).twice.and_return(nil, ".")
+      Dnif.should_receive(:root_path=).with("/expanded/path")
+      Dnif.should_receive(:environment).and_return("development")
+
+      Dnif.config_path.should == "./config/sphinx/development.erb"
+    end
+
+    it "should return specified root_path" do
+      Dnif.should_receive(:root_path).twice.and_return("/root/path", "/root/path")
+      Dnif.should_receive(:environment).and_return("development")
+
+      Dnif.config_path.should == "/root/path/config/sphinx/development.erb"
+    end
+  end
+
+  private
+
+    def results_for_post
+      {
+        :matches => [{
+                       :doc => 2983,
+                       :attributes => {
+                         "class_name" => "336,623,883,1140"
+                       }
+        }]
+      }
+    end
+
+    def results_for_comment
+      {
+        :matches => [{
+                       :doc => 7893,
+                       :attributes => {
+                         "class_name" => "323,623,877,1133,1381,1646,1908"
+                       }
+        }]
+      }
+    end
+end

data/spec/dnif/document_spec.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Dnif::Document do
+
+  describe "#generate" do
+
+    it "should generate a single document" do
+      Dnif::MultiAttribute.should_receive(:encode).with("User").and_return("1,2,3,4")
+
+      user = User.create!(:name => "Rafael Souza", :active => true, :weight => 34.5)
+
+      document = Dnif::Document.new(user)
+      expected = File.read(File.dirname(__FILE__) + "/../fixtures/sphinx_5.xml")
+      document.generate.should == expected
+    end
+  end
+
+  describe "#document_id" do
+
+    it "should calculate document id for sphinx" do
+      user = User.create!(:name => "Rafael Souza", :active => true)
+
+      document = Dnif::Document.new(user)
+      document.document_id.should == user.id + [ 341, 627, 869, 1138].sum
+    end
+  end
+
+  it "should convert date/datetime values to timestamp" do
+    now = DateTime.now
+    now.should_receive(:to_i)
+    expire = Date.today + 2.days
+    expire.should_receive(:to_i)
+    expire.should_receive(:to_datetime).and_return(expire)
+
+    note = Note.create!(
+      :title => "Note Title",
+      :clicked => 10,
+      :published_at => now,
+      :expire_at => expire,
+      :active => true,
+      :points => 1000
+    )
+    note.to_sphinx
+  end
+end

data/spec/dnif/index_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Dnif::Index do
+
+  it "should define a field" do
+    index = Dnif::Index.new(&proc { field :name })
+    index.fields.should == [ :name ]
+  end
+
+  it "should define an attribute" do
+    index = Dnif::Index.new(&proc { attribute :another, :type => :bool })
+    index.attributes.should == { :another => :bool }
+  end
+
+  it "should define where clause" do
+    index = Dnif::Index.new(&proc { where "field = 'value'" })
+    index.conditions.should == "field = 'value'"
+  end
+end

data/spec/dnif/indexer_spec.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Dnif::Indexer do
+
+  describe ".define_index" do
+
+    it ".define_index" do
+      klass = Class.new
+      klass.extend(Dnif::Indexer)
+      klass.should_receive(:name).and_return("Klass")
+      klass.define_index do
+        field :a
+        attribute :b, :type => :integer
+        where "c"
+      end
+
+      klass.indexes["Klass"].fields.should == [ :a ]
+      klass.indexes["Klass"].attributes.should == { :b => :integer }
+      klass.indexes["Klass"].conditions.should == "c"
+
+      klass.indexes.delete("Klass")
+    end
+  end
+
+  it "should not include Index if there is no index definition inside the class" do
+    Post.new.respond_to?(:to_sphinx).should be_false
+    Post.respond_to?(:to_sphinx).should be_false
+  end
+
+  describe "#to_sphinx" do
+
+    it "should return a sphinx document including defined fields" do
+      comment = Person.create!(:first_name => "Rafael", :last_name => "Souza")
+
+      expected = File.read(File.dirname(__FILE__) + "/../fixtures/sphinx_3.xml")
+      comment.to_sphinx.should == expected
+    end
+
+    it "should return a sphinx document including defined attributes" do
+      note = Note.create!(:id => 1, :title => "Note Title", :clicked => 10, :published_at => (now = DateTime.now), :expire_at => (expire = Date.today + 2.days), :active => true, :points => 1000)
+
+      expected = File.read(File.dirname(__FILE__) + "/../fixtures/sphinx_2.xml")
+      note.to_sphinx.should == expected.gsub("{now}", now.to_i.to_s).gsub("{expire}", expire.to_datetime.to_i.to_s)
+    end
+  end
+
+  describe ".to_sphinx" do
+
+    it "should generate a full sphinx xml" do
+      comment = Person.create!(:first_name => "Rafael", :last_name => "Souza")
+
+      expected = File.read(File.dirname(__FILE__) + "/../fixtures/sphinx_1.xml")
+      Person.to_sphinx.should == expected.gsub("{comment}", comment.to_sphinx)
+    end
+  end
+
+  describe ".indexes" do
+
+    it "should return all indexed classes" do
+      ActiveRecord::Base.indexes.keys.should == ["User", "Person", "Order", "Note"]
+    end
+  end
+end