pose 1.2.0 → 1.2.1

data/spec/support/matchers.rb

@@ -0,0 +1,20 @@
+# Verifies that a posable object has the given pose words in its search index.
+RSpec::Matchers.define :have_pose_words do |expected|
+
+  match do |actual|
+    actual.should have(expected.size).pose_words
+    texts = actual.pose_words.map &:text
+    expected.each do |expected_word|
+      # Note (KG): Can't use text.should include(expected_word) here
+      #            because Ruby thinks I want to include a Module for some reason.
+      texts.include?(expected_word).should be_true
+    end
+  end
+
+  failure_message_for_should do |actual|
+    texts = actual.pose_words.map &:text
+    "expected that subject would have pose words [#{expected.join ', '}], but it has [#{texts.join ', '}]"
+  end
+
+end
+

data/spec/support/models.rb

@@ -0,0 +1,8 @@
+class PosableOne < ActiveRecord::Base
+  posify { text }
+end
+
+class PosableTwo < ActiveRecord::Base
+  posify { text }
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pose
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-30 00:00:00.000000000 Z
+date: 2012-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -75,6 +75,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: factory_girl
   requirement: !ruby/object:Gem::Requirement
@@ -183,12 +199,13 @@ files:
 - doc/top-level-namespace.html
 - lib/generators/pose_generator.rb
 - lib/generators/templates/migration.rb
-- lib/pose/base_additions.rb
+- lib/pose/activerecord_base_additions.rb
+- lib/pose/internal_helpers.rb
 - lib/pose/model_additions.rb
 - lib/pose/models/pose_assignment.rb
 - lib/pose/models/pose_word.rb
 - lib/pose/railtie.rb
-- lib/pose/static_helpers.rb
+- lib/pose/static_api.rb
 - lib/pose/version.rb
 - lib/pose.rb
 - lib/tasks/pose_tasks.rake
@@ -196,10 +213,13 @@ files:
 - Rakefile
 - README.md
 - spec/factories.rb
+- spec/internal_helpers_spec.rb
+- spec/pose_api_spec.rb
 - spec/pose_assignment_spec.rb
-- spec/pose_spec.rb
 - spec/pose_word_spec.rb
 - spec/spec_helper.rb
+- spec/support/matchers.rb
+- spec/support/models.rb
 homepage: http://github.com/kevgo/pose
 licenses: []
 post_install_message: 
@@ -226,7 +246,10 @@ specification_version: 3
 summary: A polymorphic, storage-system independent search engine for Ruby on Rails.
 test_files:
 - spec/factories.rb
+- spec/internal_helpers_spec.rb
+- spec/pose_api_spec.rb
 - spec/pose_assignment_spec.rb
-- spec/pose_spec.rb
 - spec/pose_word_spec.rb
 - spec/spec_helper.rb
+- spec/support/matchers.rb
+- spec/support/models.rb

data/lib/pose/static_helpers.rb

@@ -1,173 +0,0 @@
-# Static helper methods of the Pose gem. 
-module Pose
-  extend ActiveSupport::Concern
-
-  # By default, doesn't run in tests.
-  # Set this to true to test the search functionality.
-  CONFIGURATION = { search_in_tests: false }
-
-  class <<self
-
-    # Returns whether Pose is configured to perform search.
-    # This setting exists to disable search in tests.
-    #
-    # @return [false, true]
-    def perform_search?
-      !(Rails.env == 'test' and !CONFIGURATION[:search_in_tests])
-    end
-
-    # Returns all words that begin with the given query string.
-    # This can be used for autocompletion functionality.
-    #
-    # @param [String]
-    # @return [Array<String>]
-    def autocomplete_words query
-      return [] if query.blank?
-      PoseWord.where('text LIKE ?', "#{Pose.root_word(query)[0]}%").map(&:text)
-    end
-
-    # Returns all strings that are in new_words, but not in existing_words.
-    # Helper method.
-    #
-    # @param [Array<String>] existing_words The words that are already associated with the object.
-    # @param [Array<String>] new_words The words thet the object should have from now on.
-    #
-    # @return [Array<String>] The words that need to be added to the existing_words array.
-    def get_words_to_add existing_words, new_words
-      new_words - existing_words.map(&:text)
-    end
-
-    # Helper method.
-    # Returns the id of all word objects that are in existing_words, but not in new_words.
-    #
-    # @param [Array<String>] existing_words The words that are already associated with the object.
-    # @param [Array<String>] new_words The words thet the object should have from now on.
-    #
-    # @return [Array<String>] The words that need to be removed from the existing_words array.
-    def get_words_to_remove existing_words, new_words
-      existing_words.map do |existing_word|
-        existing_word unless new_words.include?(existing_word.text)
-      end.compact
-    end
-
-    # Returns whether the given string is a URL.
-    #
-    # @param [String] word The string to check.
-    #
-    # @return [Boolean]
-    def is_url? word
-      URI::parse(word).scheme == 'http'
-    rescue URI::InvalidURIError
-      false
-    end
-
-    # Simplifies the given word to a generic search form.
-    #
-    # @param [String] raw_word The word to make searchable.
-    #
-    # @return [String] The stemmed version of the word.
-    def root_word raw_word
-      result = []
-      raw_word_copy = raw_word[0..-1]
-      raw_word_copy.gsub! '%20', ' '
-      raw_word_copy.gsub! /[()*<>'",;\?\-\=&%#]/, ' '
-      raw_word_copy.gsub! /\s+/, ' '
-      raw_word_copy.split(' ').each do |word|
-        if Pose.is_url?(word)
-          result.concat word.split(/[\.\/\:]/).delete_if(&:blank?)
-        else
-          word.gsub! /[\-\/\._:]/, ' '
-          word.gsub! /\s+/, ' '
-          word.split(' ').each do |w|
-            stemmed_word =  w.parameterize.singularize
-            result.concat stemmed_word.split ' '
-          end
-        end
-      end
-      result.uniq
-    end
-
-    # Returns all objects matching the given query.
-    #
-    # @param [String] query
-    # @param (Class|[Array<Class>]) classes
-    # @param [Hash?] options Additional options.
-    #
-    # @return [Hash<Class, ActiveRecord::Relation>]
-    def search query, classes, options = {}
-
-      # Turn 'classes' into an array.
-      classes = [classes].flatten
-      classes_names = classes.map &:name
-      classes_names = classes_names[0] if classes_names.size == 1
-
-      # Get the ids of the results.
-      result_classes_and_ids = {}
-      query_words = query.split(' ').map{|query_word| Pose.root_word query_word}.flatten
-      query_words.each do |query_word|
-        current_word_classes_and_ids = {}
-        classes.each { |clazz| current_word_classes_and_ids[clazz.name] = [] }
-        query = PoseAssignment.joins(:pose_word) \
-                              .select('pose_assignments.posable_id, pose_assignments.posable_type') \
-                              .where('pose_words.text LIKE ?', "#{query_word}%") \
-                              .where('posable_type IN (?)', classes_names)
-        PoseAssignment.connection.select_all(query.to_sql).each do |pose_assignment|
-          current_word_classes_and_ids[pose_assignment['posable_type']] << pose_assignment['posable_id'].to_i
-        end
-        # This is the old ActiveRecord way. Removed for performance reasons.
-        # query.each do |pose_assignment|
-        #   current_word_classes_and_ids[pose_assignment.posable_type] << pose_assignment.posable_id
-        # end
-
-        current_word_classes_and_ids.each do |class_name, ids|
-          if result_classes_and_ids.has_key? class_name
-            result_classes_and_ids[class_name] = result_classes_and_ids[class_name] & ids
-          else
-            result_classes_and_ids[class_name] = ids
-          end
-        end
-      end
-
-      # Load the results by id.
-      {}.tap do |result|
-        result_classes_and_ids.each do |class_name, ids|
-          result_class = Kernel.const_get class_name
-
-          if ids.size == 0
-            # Handle no results.
-            result[result_class] = []
-
-          else
-            # Here we have results.
-
-            # Limit.
-            ids = ids.slice(0, options[:limit]) if options[:limit]
-
-            if options[:result_type] == :ids
-              # Ids requested for result.
-
-              if options.has_key? :scope
-                # We have a scope.
-                options[:scope].each do |scope|
-                  result[result_class] = result_class.select('id').where(scope).map(&:id)
-                end
-              else
-                result[result_class] = ids
-              end
-
-            else
-              # Classes requested for result.
-
-              result[result_class] = result_class.where(id: ids)
-              if options.has_key? :scope
-                options[:scope].each do |scope|
-                  result[result_class] = result[result_class].where(scope)
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/pose_spec.rb

@@ -1,401 +0,0 @@
-# encoding: utf-8
-
-require "spec_helper"
-
-ActiveRecord::Base.establish_connection adapter: 'postgresql', database: 'pose_test', min_messages: 'WARNING'
-
-describe Pose do
-  subject { PosableOne.new }
-
-  before :each do
-    PosableOne.delete_all
-    PosableTwo.delete_all
-    PoseAssignment.delete_all
-    PoseWord.delete_all
-  end
-
-  describe 'associations' do
-    it 'allows to access the associated words of a posable object directly' do
-      subject.should have(0).pose_words
-      subject.pose_words << PoseWord.new(text: 'one')
-      subject.should have_pose_words(['one'])
-    end
-  end
-
-  describe 'update_pose_index' do
-
-    context "in the 'test' environment" do
-      after :each do
-        Pose::CONFIGURATION[:search_in_tests] = true
-      end
-
-      it "doesn't calls update_pose_words in tests if the test flag is not enabled" do
-        Pose::CONFIGURATION[:search_in_tests] = false
-        subject.should_not_receive :update_pose_words
-        subject.update_pose_index
-      end
-
-      it "calls update_pose_words in tests if the test flag is enabled" do
-        Pose::CONFIGURATION[:search_in_tests] = true
-        subject.should_receive :update_pose_words
-        subject.update_pose_index
-      end
-    end
-
-    context "in the 'production' environment' do" do
-      before :each do
-        @old_env = Rails.env
-        Rails.env = 'production'
-      end
-
-      after :each do
-        Rails.env = @old_env
-      end
-
-      it "calls update_pose_words" do
-        subject.should_receive :update_pose_words
-        subject.update_pose_index
-      end
-    end
-  end
-
-  describe 'update_pose_words' do
-
-    it 'saves the words for search' do
-      subject.text = 'foo bar'
-      subject.update_pose_words
-      subject.should have(2).pose_words
-      subject.should have_pose_words ['foo', 'bar']
-    end
-
-    it 'updates the search index when the text is changed' do
-      subject.text = 'foo'
-      subject.save!
-
-      subject.text = 'other text'
-      subject.update_pose_words
-
-      subject.should have_pose_words ['other', 'text']
-    end
-
-    it "doesn't create duplicate words" do
-      subject.text = 'foo foo'
-      subject.save!
-      subject.should have(1).pose_words
-    end
-  end
-
-  describe 'get_words_to_remove' do
-
-    it "returns an array of word objects that need to be removed" do
-      word1 = PoseWord.new text: 'one'
-      word2 = PoseWord.new text: 'two'
-      existing_words = [word1, word2]
-      new_words = ['one', 'three']
-
-      result = Pose.get_words_to_remove existing_words, new_words
-
-      result.should eql([word2])
-    end
-
-    it 'returns an empty array if there are no words to be removed' do
-      word1 = PoseWord.new text: 'one'
-      word2 = PoseWord.new text: 'two'
-      existing_words = [word1, word2]
-      new_words = ['one', 'two']
-
-      result = Pose.get_words_to_remove existing_words, new_words
-
-      result.should eql([])
-    end
-  end
-
-  describe 'get_words_to_add' do
-
-    it 'returns an array with strings that need to be added' do
-      word1 = PoseWord.new text: 'one'
-      word2 = PoseWord.new text: 'two'
-      existing_words = [word1, word2]
-      new_words = ['one', 'three']
-
-      result = Pose.get_words_to_add existing_words, new_words
-
-      result.should eql(['three'])
-    end
-
-    it 'returns an empty array if there is nothing to be added' do
-      word1 = PoseWord.new text: 'one'
-      word2 = PoseWord.new text: 'two'
-      existing_words = [word1, word2]
-      new_words = ['one', 'two']
-
-      result = Pose.get_words_to_add existing_words, new_words
-
-      result.should eql([])
-    end
-  end
-
-  describe 'root_word' do
-
-    it 'converts words into singular' do
-      Pose.root_word('bars').should eql(['bar'])
-    end
-
-    it 'removes special characters' do
-      Pose.root_word('(bar').should eql(['bar'])
-      Pose.root_word('bar)').should eql(['bar'])
-      Pose.root_word('(bar)').should eql(['bar'])
-      Pose.root_word('>foo').should eql(['foo'])
-      Pose.root_word('<foo').should eql(['foo'])
-      Pose.root_word('"foo"').should eql(['foo'])
-      Pose.root_word('"foo').should eql(['foo'])
-      Pose.root_word("'foo'").should eql(['foo'])
-      Pose.root_word("'foo's").should eql(['foo'])
-      Pose.root_word("foo?").should eql(['foo'])
-      Pose.root_word("foo!").should eql(['foo'])
-      Pose.root_word("foo/bar").should eql(['foo', 'bar'])
-      Pose.root_word("foo-bar").should eql(['foo', 'bar'])
-      Pose.root_word("foo--bar").should eql(['foo', 'bar'])
-      Pose.root_word("foo.bar").should eql(['foo', 'bar'])
-    end
-
-    it 'removes umlauts' do
-      Pose.root_word('fünf').should eql(['funf'])
-    end
-
-    it 'splits up numbers' do
-      Pose.root_word('11.2.2011').should eql(['11', '2', '2011'])
-      Pose.root_word('11-2-2011').should eql(['11', '2', '2011'])
-      Pose.root_word('30:4-5').should eql(['30', '4', '5'])
-    end
-
-    it 'converts into lowercase' do
-      Pose.root_word('London').should eql(['london'])
-    end
-
-    it "stores single-letter words" do
-      Pose.root_word('a b').should eql(['a', 'b'])
-    end
-
-    it "does't encode external URLs" do
-      Pose.root_word('http://web.com').should eql(['http', 'web', 'com'])
-    end
-
-    it "doesn't store empty words" do
-      Pose.root_word('  one two  ').should eql(['one', 'two'])
-    end
-
-    it "removes duplicates" do
-      Pose.root_word('one_one').should eql(['one'])
-      Pose.root_word('one one').should eql(['one'])
-    end
-
-    it "splits up complex URLs" do
-      Pose.root_word('books?id=p7uyWPcVGZsC&dq=closure%20definitive%20guide&pg=PP1#v=onepage&q&f=false').should eql([
-        "book", "id", "p7uywpcvgzsc", "dq", "closure", "definitive", "guide", "pg", "pp1", "v", "onepage", "q", "f", "false"])
-    end
-  end
-
-  describe 'search' do
-
-    it 'works' do
-      pos1 = PosableOne.create text: 'one'
-
-      result = Pose.search 'one', PosableOne
-
-      result.should have(1).items
-      result[PosableOne].should have(1).items
-      result[PosableOne][0].should == pos1
-    end
-
-    describe 'classes parameter' do
-      it 'returns all different classes by default' do
-        pos1 = PosableOne.create text: 'foo'
-        pos2 = PosableTwo.create text: 'foo'
-
-        result = Pose.search 'foo', [PosableOne, PosableTwo]
-
-        result.should have(2).items
-        result[PosableOne].should == [pos1]
-        result[PosableTwo].should == [pos2]
-      end
-
-      it 'allows to provide different classes to return' do
-        pos1 = PosableOne.create text: 'foo'
-        pos2 = PosableTwo.create text: 'foo'
-
-        result = Pose.search 'foo', [PosableOne, PosableTwo]
-
-        result.should have(2).items
-        result[PosableOne].should == [pos1]
-        result[PosableTwo].should == [pos2]
-      end
-
-      it 'returns only instances of the given classes' do
-        pos1 = PosableOne.create text: 'one'
-        pos2 = PosableTwo.create text: 'one'
-
-        result = Pose.search 'one', PosableOne
-
-        result.should have(1).items
-        result[PosableOne].should == [pos1]
-      end
-    end
-
-    describe 'query parameter' do
-
-      it 'returns an empty array if nothing matches' do
-        pos1 = PosableOne.create text: 'one'
-
-        result = Pose.search 'two', PosableOne
-
-        result.should == { PosableOne => [] }
-      end
-
-      it 'returns only objects that match all given query words' do
-        pos1 = PosableOne.create text: 'one two'
-        pos2 = PosableOne.create text: 'one three'
-        pos3 = PosableOne.create text: 'two three'
-
-        result = Pose.search 'two one', PosableOne
-
-        result.should have(1).items
-        result[PosableOne].should == [pos1]
-      end
-
-      it 'returns nothing if searching for a non-existing word' do
-        pos1 = PosableOne.create text: 'one two'
-
-        result = Pose.search 'one zonk', PosableOne
-
-        result.should have(1).items
-        result[PosableOne].should == []
-      end
-
-      it 'works if the query is given in uppercase' do
-        pos1 = PosableOne.create text: 'one two'
-
-        result = Pose.search 'OnE TwO', PosableOne
-
-        result.should have(1).items
-        result[PosableOne].should == [pos1]
-      end
-    end
-
-    describe "'limit' parameter" do
-
-      it 'works' do
-        FactoryGirl.create :posable_one, text: 'foo one'
-        FactoryGirl.create :posable_one, text: 'foo two'
-        FactoryGirl.create :posable_one, text: 'foo three'
-        FactoryGirl.create :posable_one, text: 'foo four'
-
-        result = Pose.search 'foo', PosableOne, limit: 3
-
-        result[PosableOne].should have(3).items
-      end
-    end
-
-    describe "'result_type' parameter" do
-
-      before :each do
-        @foo_one = FactoryGirl.create :posable_one, text: 'foo one'
-      end
-
-      describe 'default behavior' do
-        it 'returns full objects' do
-          result = Pose.search 'foo', PosableOne
-          result[PosableOne][0].should == @foo_one
-        end
-      end
-
-      context ':ids given' do
-        it 'returns ids instead of objects' do
-          result = Pose.search 'foo', PosableOne, result_type: :ids
-          result[PosableOne][0].should == @foo_one.id
-        end
-      end
-    end
-
-    describe "'scopes' parameter" do
-
-      before :each do
-        @one = FactoryGirl.create :posable_one, text: 'foo one', private: true
-        @two = FactoryGirl.create :posable_one, text: 'foo two', private: false
-      end
-
-      context 'with result type :classes' do
-
-        it 'limits the result set by the given scope' do
-          result = Pose.search 'foo', PosableOne, scope: [ private: true ]
-          result[PosableOne].should have(1).item
-          result[PosableOne].should include @one
-        end
-
-        it 'allows to use the hash syntax for queries' do
-          result = Pose.search 'foo', PosableOne, scope: [ private: true ]
-          result[PosableOne].should have(1).item
-          result[PosableOne].should include @one
-        end
-
-        it 'allows to use the string syntax for queries' do
-          result = Pose.search 'foo', PosableOne, scope: [ ['private = ?', true] ]
-          result[PosableOne].should have(1).item
-          result[PosableOne].should include @one
-        end
-
-        it 'allows to combine several scopes' do
-          @three = FactoryGirl.create :posable_one, text: 'foo two', private: true
-          result = Pose.search 'foo', PosableOne, scope: [ {private: true}, ['text = ?', 'foo two'] ]
-          result[PosableOne].should have(1).item
-          result[PosableOne].should include @three
-        end
-      end
-
-      context 'with result type :ids' do
-
-        it 'limits the result set by the given scope' do
-          result = Pose.search 'foo', PosableOne, result_type: :ids, scope: [ private: true ]
-          result[PosableOne].should have(1).item
-          result[PosableOne].should include @one.id
-        end
-      end
-    end
-  end
-
-  describe 'autocomplete_words' do
-
-    it 'returns words that start with the given phrase' do
-      PosableOne.create text: 'great green pine tree'
-
-      result = Pose.autocomplete_words 'gr'
-
-      result.should have(2).words
-      result.should include('great')
-      result.should include('green')
-    end
-
-    it 'returns words that match the given phrase exactly' do
-      PoseWord.create text: 'cat'
-
-      result = Pose.autocomplete_words 'cat'
-
-      result.should == ['cat']
-    end
-
-    it 'stems the search query' do
-      PosableOne.create text: 'car'
-
-      result = Pose.autocomplete_words 'cars'
-
-      result.should have(1).words
-      result[0].should == 'car'
-    end
-
-    it 'returns nothing if the search query is empty' do
-      PosableOne.create text: 'foo bar'
-      result = Pose.autocomplete_words ''
-      result.should have(0).words
-    end
-  end
-end