mongoid-haystack 1.0.0

data/lib/mongoid-haystack/util.rb

@@ -0,0 +1,67 @@
+module Mongoid
+  module Haystack
+    module Util 
+      def models
+        [
+          Mongoid::Haystack::Token,
+          Mongoid::Haystack::Index,
+          Mongoid::Haystack::Count,
+          Mongoid::Haystack::Sequence
+        ]
+      end
+
+      def reset!
+        models.each do |model|
+          begin
+            model.collection.indexes.drop
+          rescue Object => e
+          end
+
+          begin
+            model.collection.drop
+          rescue Object => e
+          end
+
+          begin
+            model.create_indexes
+          rescue Object => e
+          end
+        end
+      end
+
+      def destroy_all
+        models.map{|model| model.destroy_all}
+      end
+
+      def stem(*args, &block)
+        Stemming.stem(*args, &block)
+      end
+
+      def find_or_create(finder, creator)
+        doc = finder.call()
+        return doc if doc
+
+        n, max = 0, 2
+
+        begin
+          creator.call()
+        rescue Object => e
+          n += 1
+          raise if n > max
+          sleep(rand(0.1))
+          finder.call() or retry
+        end
+      end
+
+      def connect!
+        Mongoid.configure do |config|
+          config.connect_to('mongoid-haystack')
+        end
+      end
+
+      extend Util
+    end
+
+    extend Util
+  end
+end

data/mongoid-haystack.gemspec

@@ -0,0 +1,73 @@
+## mongoid-haystack.gemspec
+#
+
+Gem::Specification::new do |spec|
+  spec.name = "mongoid-haystack"
+  spec.version = "1.0.0"
+  spec.platform = Gem::Platform::RUBY
+  spec.summary = "mongoid-haystack"
+  spec.description = "a mongoid 3 zero-config, zero-integration, POLS pure mongo fulltext solution"
+
+  spec.files =
+["Rakefile",
+ "lib",
+ "lib/app",
+ "lib/app/models",
+ "lib/app/models/mongoid",
+ "lib/app/models/mongoid/haystack",
+ "lib/app/models/mongoid/haystack/count.rb",
+ "lib/app/models/mongoid/haystack/index.rb",
+ "lib/app/models/mongoid/haystack/sequence.rb",
+ "lib/app/models/mongoid/haystack/token.rb",
+ "lib/mongoid-haystack",
+ "lib/mongoid-haystack.rb",
+ "lib/mongoid-haystack/count.rb",
+ "lib/mongoid-haystack/index.rb",
+ "lib/mongoid-haystack/search.rb",
+ "lib/mongoid-haystack/sequence.rb",
+ "lib/mongoid-haystack/stemming",
+ "lib/mongoid-haystack/stemming.rb",
+ "lib/mongoid-haystack/stemming/stopwords",
+ "lib/mongoid-haystack/stemming/stopwords/english.txt",
+ "lib/mongoid-haystack/stemming/stopwords/extended_english.txt",
+ "lib/mongoid-haystack/stemming/stopwords/full_danish.txt",
+ "lib/mongoid-haystack/stemming/stopwords/full_dutch.txt",
+ "lib/mongoid-haystack/stemming/stopwords/full_english.txt",
+ "lib/mongoid-haystack/stemming/stopwords/full_finnish.txt",
+ "lib/mongoid-haystack/stemming/stopwords/full_french.txt",
+ "lib/mongoid-haystack/stemming/stopwords/full_german.txt",
+ "lib/mongoid-haystack/stemming/stopwords/full_italian.txt",
+ "lib/mongoid-haystack/stemming/stopwords/full_norwegian.txt",
+ "lib/mongoid-haystack/stemming/stopwords/full_portuguese.txt",
+ "lib/mongoid-haystack/stemming/stopwords/full_russian.txt",
+ "lib/mongoid-haystack/stemming/stopwords/full_russiankoi8_r.txt",
+ "lib/mongoid-haystack/stemming/stopwords/full_spanish.txt",
+ "lib/mongoid-haystack/token.rb",
+ "lib/mongoid-haystack/util.rb",
+ "mongoid-haystack.gemspec",
+ "test",
+ "test/helper.rb",
+ "test/mongoid-haystack_test.rb",
+ "test/testing.rb"]
+
+  spec.executables = []
+  
+  spec.require_path = "lib"
+
+  spec.test_files = nil
+
+  
+    spec.add_dependency(*["mongoid", "~> 3.0"])
+  
+    spec.add_dependency(*["map", "~> 6.2"])
+  
+    spec.add_dependency(*["fattr", "~> 2.2"])
+  
+
+  spec.extensions.push(*[])
+
+  spec.rubyforge_project = "codeforpeople"
+  spec.author = "Ara T. Howard"
+  spec.email = "ara.t.howard@gmail.com"
+  spec.homepage = "https://github.com/ahoward/mongoid-haystack"
+end

data/test/helper.rb

@@ -0,0 +1,28 @@
+# -*- encoding : utf-8 -*-
+
+# this triggers mongoid to load rails...
+# module Rails; end
+
+require_relative 'testing'
+require_relative '../lib/mongoid-haystack.rb'
+
+Mongoid::Haystack.connect!
+
+class A
+  include Mongoid::Document
+  field(:content, :type => String)
+  def to_s; content; end
+end
+
+class B
+  include Mongoid::Document
+  field(:content, :type => String)
+  def to_s; content; end
+end
+
+class C
+  include Mongoid::Document
+  field(:content, :type => String)
+  def to_s; content; end
+end
+

data/test/mongoid-haystack_test.rb

@@ -0,0 +1,119 @@
+require_relative 'helper'
+
+Testing Mongoid::Haystack do
+##
+#
+  Mongoid::Haystack.reset!
+
+  setup do
+    [A, B, C].map{|m| m.destroy_all}
+    Mongoid::Haystack.destroy_all
+  end
+
+##
+#
+  testing 'that models can, at minimum, be indexed and searched' do
+    a = A.create!(:content => 'dog')
+    b = B.create!(:content => 'cat')
+
+    assert{ Mongoid::Haystack.index(a) }
+    assert{ Mongoid::Haystack.index(b) }
+
+    assert{ Mongoid::Haystack.search('dog').map(&:model) == [a] }
+    assert{ Mongoid::Haystack.search('cat').map(&:model) == [b] }
+  end
+
+##
+#
+  testing 'that word occurance affects the sort' do
+    a = A.create!(:content => 'dog')
+    b = A.create!(:content => 'dog dog')
+    c = A.create!(:content => 'dog dog dog')
+    
+    assert{ Mongoid::Haystack.index(A) }
+    assert{ Mongoid::Haystack.search('dog').map(&:model) == [c, b, a] }
+  end
+
+##
+#
+  testing 'that rare words float to the front of the results' do
+    a = A.create!(:content => 'dog')
+    b = A.create!(:content => 'dog dog')
+    c = A.create!(:content => 'dog dog dog')
+    d = A.create!(:content => 'dog dog dog cat')
+    
+    assert{ Mongoid::Haystack.index(A) }
+    assert{ Mongoid::Haystack.search('cat dog').map(&:model) == [d, c, b, a] }
+  end
+
+##
+#
+  testing 'that basic stemming can be performed' do
+    assert{ Mongoid::Haystack.stem('dogs cats') == %w[ dog cat ] }
+  end
+
+  testing 'that words are stemmed when they are indexed' do
+    a = A.create!(:content => 'dog')
+    b = A.create!(:content => 'dogs')
+    c = A.create!(:content => 'dogen')
+
+    assert{ Mongoid::Haystack.index(A) }
+
+    assert{
+      results = Mongoid::Haystack.search('dog').map(&:model)
+      results.include?(a) and results.include?(b) and !results.include?(c)
+    }
+  end
+
+##
+#
+  testing 'that counts are kept regarding each seen token' do
+    a = A.create!(:content => 'dog')
+    b = A.create!(:content => 'dogs')
+    c = A.create!(:content => 'cat')
+
+    assert{ Mongoid::Haystack.index(A) }
+
+    assert{ Mongoid::Haystack::Token.count == 2 }
+    assert{ Mongoid::Haystack::Token.all.map(&:value).sort == %w( cat dog ) }
+    assert{ Mongoid::Haystack::Count[:tokens].value == 3 }
+  end
+
+  testing 'that removing a model from the index decrements counts appropriately' do
+  #
+    a = A.create!(:content => 'dog')
+    b = A.create!(:content => 'cat')
+    c = A.create!(:content => 'cats dogs')
+
+    assert{ Mongoid::Haystack.index(A) }
+
+  #
+    assert{ Mongoid::Haystack.search('cat').first }
+
+    assert{ Mongoid::Haystack::Token.where(:value => 'cat').first.count == 2 }
+    assert{ Mongoid::Haystack::Token.where(:value => 'dog').first.count == 2 }
+    assert{ Mongoid::Haystack::Count[:tokens].value == 4 }
+    assert{ Mongoid::Haystack::Token.all.map(&:value).sort == %w( cat dog ) }
+    assert{ Mongoid::Haystack.unindex(c) }
+    assert{ Mongoid::Haystack::Token.all.map(&:value).sort == %w( cat dog ) }
+    assert{ Mongoid::Haystack::Count[:tokens].value == 2 }
+    assert{ Mongoid::Haystack::Token.where(:value => 'cat').first.count == 1 }
+    assert{ Mongoid::Haystack::Token.where(:value => 'dog').first.count == 1 }
+
+    assert{ Mongoid::Haystack::Count[:tokens].value == 2 }
+    assert{ Mongoid::Haystack::Token.all.map(&:value).sort == %w( cat dog ) }
+    assert{ Mongoid::Haystack.unindex(b) }
+    assert{ Mongoid::Haystack::Token.all.map(&:value).sort == %w( cat dog ) }
+    assert{ Mongoid::Haystack::Count[:tokens].value == 1 }
+    assert{ Mongoid::Haystack::Token.where(:value => 'cat').first.count == 0 }
+    assert{ Mongoid::Haystack::Token.where(:value => 'dog').first.count == 1 }
+
+    assert{ Mongoid::Haystack::Count[:tokens].value == 1 }
+    assert{ Mongoid::Haystack::Token.all.map(&:value).sort == %w( cat dog ) }
+    assert{ Mongoid::Haystack.unindex(a) }
+    assert{ Mongoid::Haystack::Token.all.map(&:value).sort == %w( cat dog ) }
+    assert{ Mongoid::Haystack::Count[:tokens].value == 0 }
+    assert{ Mongoid::Haystack::Token.where(:value => 'cat').first.count == 0 }
+    assert{ Mongoid::Haystack::Token.where(:value => 'dog').first.count == 0 }
+  end
+end

data/test/testing.rb

@@ -0,0 +1,196 @@
+# -*- encoding : utf-8 -*-
+require 'test/unit'
+
+testdir = File.expand_path(File.dirname(__FILE__))
+rootdir = File.dirname(testdir)
+libdir = File.join(rootdir, 'lib')
+
+STDOUT.sync = true
+
+$:.unshift(testdir) unless $:.include?(testdir)
+$:.unshift(libdir) unless $:.include?(libdir)
+$:.unshift(rootdir) unless $:.include?(rootdir)
+
+class Testing
+  class Slug < ::String
+    def Slug.for(*args)
+      string = args.flatten.compact.join('-')
+      words = string.to_s.scan(%r/\w+/)
+      words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
+      words.delete_if{|word| word.nil? or word.strip.empty?}
+      new(words.join('-').downcase)
+    end
+  end
+  
+  class Context
+    attr_accessor :name
+
+    def initialize(name, *args)
+      @name = name
+    end
+
+    def to_s
+      Slug.for(name)
+    end
+  end
+end
+
+def Testing(*args, &block)
+  Class.new(::Test::Unit::TestCase) do
+
+  ## class methods
+  #
+    class << self
+      def contexts
+        @contexts ||= []
+      end
+
+      def context(*args, &block)
+        return contexts.last if(args.empty? and block.nil?)
+
+        context = Testing::Context.new(*args)
+        contexts.push(context)
+
+        begin
+          block.call(context)
+        ensure
+          contexts.pop
+        end
+      end
+
+      def slug_for(*args)
+        string = [context, args].flatten.compact.join('-')
+        words = string.to_s.scan(%r/\w+/)
+        words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
+        words.delete_if{|word| word.nil? or word.strip.empty?}
+        words.join('-').downcase.sub(/_$/, '')
+      end
+
+      def name() const_get(:Name) end
+
+      def testno()
+        '%05d' % (@testno ||= 0)
+      ensure
+        @testno += 1
+      end
+
+      def testing(*args, &block)
+        method = ["test", testno, slug_for(*args)].delete_if{|part| part.empty?}.join('_')
+        define_method(method, &block)
+      end
+
+      def test(*args, &block)
+        testing(*args, &block)
+      end
+
+      def setup(&block)
+        define_method(:setup, &block) if block
+      end
+
+      def teardown(&block)
+        define_method(:teardown, &block) if block
+      end
+
+      def prepare(&block)
+        @prepare ||= []
+        @prepare.push(block) if block
+        @prepare
+      end
+
+      def cleanup(&block)
+        @cleanup ||= []
+        @cleanup.push(block) if block
+        @cleanup
+      end
+    end
+
+  ## configure the subclass!
+  #
+    const_set(:Testno, '0')
+    slug = slug_for(*args).gsub(%r/-/,'_')
+    name = ['TESTING', '%03d' % const_get(:Testno), slug].delete_if{|part| part.empty?}.join('_')
+    name = name.upcase!
+    const_set(:Name, name)
+    const_set(:Missing, Object.new.freeze)
+
+  ## instance methods
+  #
+    alias_method('__assert__', 'assert')
+
+    def assert(*args, &block)
+      if args.size == 1 and args.first.is_a?(Hash)
+        options = args.first
+        expected = getopt(:expected, options){ missing }
+        actual = getopt(:actual, options){ missing }
+        if expected == missing and actual == missing
+          actual, expected, *ignored = options.to_a.flatten
+        end
+        expected = expected.call() if expected.respond_to?(:call)
+        actual = actual.call() if actual.respond_to?(:call)
+        assert_equal(expected, actual)
+      end
+
+      if block
+        label = "assert(#{ args.join(' ') })"
+        result = nil
+        assert_nothing_raised{ result = block.call }
+        __assert__(result, label)
+        result
+      else
+        result = args.shift
+        label = "assert(#{ args.join(' ') })"
+        __assert__(result, label)
+        result
+      end
+    end
+
+    def missing
+      self.class.const_get(:Missing)
+    end
+
+    def getopt(opt, hash, options = nil, &block)
+      [opt.to_s, opt.to_s.to_sym].each do |key|
+        return hash[key] if hash.has_key?(key)
+      end
+      default =
+        if block
+          block.call
+        else
+          options.is_a?(Hash) ? options[:default] : nil
+        end
+      return default
+    end
+
+    def subclass_of exception
+      class << exception
+        def ==(other) super or self > other end
+      end
+      exception
+    end
+
+  ##
+  #
+    module_eval(&block)
+
+    self.setup()
+    self.prepare.each{|b| b.call()}
+
+    at_exit{ 
+      self.teardown()
+      self.cleanup.each{|b| b.call()}
+    }
+
+    self
+  end
+end
+
+
+if $0 == __FILE__
+
+  Testing 'Testing' do
+    testing('foo'){ assert true }
+    test{ assert true }
+    p instance_methods.grep(/test/)
+  end
+
+end