pose 1.2.0 → 1.2.1

data/README.md

@@ -1,4 +1,4 @@
-# Pose <a href="http://travis-ci.org/#!/kevgo/pose" target="_blank"><img src="https://secure.travis-ci.org/kevgo/pose.png" alt="Build status"></a>
+# Pose <a href="http://travis-ci.org/#!/kevgo/pose" target="_blank"><img src="https://secure.travis-ci.org/kevgo/pose.png" alt="Build status"></a> <a href="https://codeclimate.com/github/kevgo/pose" target="_blank"><img src="https://codeclimate.com/badge.png" /></a>
 
 Pose  ("Polymorphic Search") allows fulltext search for ActiveRecord objects.
 

data/lib/pose.rb

@@ -2,8 +2,9 @@
 require 'rake'
 include Rake::DSL if defined? Rake::DSL
 
-require 'pose/static_helpers'
-require 'pose/base_additions'
+require 'pose/static_api'
+require 'pose/internal_helpers'
+require 'pose/activerecord_base_additions'
 require 'pose/model_additions'
 require 'pose/railtie' if defined? Rails
 require 'pose/models/pose_assignment'

data/lib/pose/{base_additions.rb → activerecord_base_additions.rb}

@@ -1,5 +1,6 @@
+# Additions to ActiveRecord::Base.
 module Pose
-  module BaseAdditions
+  module ActiveRecordBaseAdditions
 
     def posify &block
       raise "You must provide a block that returns the searchable content to 'posify'." unless block_given?

data/lib/pose/internal_helpers.rb

@@ -0,0 +1,118 @@
+# Internal helper methods for the Pose module.
+module Pose
+  module Helpers
+    class <<self
+
+      # 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::Helpers.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
+
+
+      # Merges the given posable object ids for a single query word into the given search result.
+      def merge_search_result_word_matches result, class_name, ids
+        if result.has_key? class_name
+          result[class_name] = result[class_name] & ids
+        else
+          result[class_name] = ids
+        end
+      end
+
+
+      # Returns a hash mapping classes to ids for the a single given word.
+      def search_classes_and_ids_for_word word, class_names
+        result = {}.tap { |hash| class_names.each { |class_name| hash[class_name] = [] }}
+        query = PoseAssignment.joins(:pose_word) \
+                              .select('pose_assignments.posable_id, pose_assignments.posable_type') \
+                              .where('pose_words.text LIKE ?', "#{word}%") \
+                              .where('posable_type IN (?)', class_names)
+        PoseAssignment.connection.select_all(query.to_sql).each do |pose_assignment|
+          result[pose_assignment['posable_type']] << pose_assignment['posable_id'].to_i
+        end
+        result
+      end
+
+
+      # Makes the given input an array.
+      def make_array input
+        [input].flatten
+      end
+
+
+      # Returns the search terms that are contained in the given query.
+      def query_terms query
+        query.split(' ').map{|query_word| Pose::Helpers.root_word query_word}.flatten.uniq
+      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::Helpers.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
+
+    end
+  end
+end

data/lib/pose/model_additions.rb

@@ -1,4 +1,4 @@
-# This Module contains code that gets added to classes that are posified.
+# Additions to posified ActiveRecord models.
 module Pose
   module ModelAdditions
     extend ActiveSupport::Concern
@@ -28,16 +28,16 @@ module Pose
     def update_pose_words
 
       # Step 1: get an array of all words for the current object.
-      search_string = instance_eval &(self.class.pose_content)
-      new_words = search_string.to_s.split(' ').map { |word| Pose.root_word(word) }.flatten.uniq
+      search_text = instance_eval &(self.class.pose_content)
+      new_words = Pose::Helpers.query_terms search_text.to_s
 
       # Step 2: Add new words to the search index.
-      Pose.get_words_to_add(self.pose_words, new_words).each do |word_to_add|
+      Pose::Helpers.get_words_to_add(self.pose_words, new_words).each do |word_to_add|
         self.pose_words << PoseWord.find_or_create_by_text(word_to_add)
       end
 
       # Step 3: Remove now obsolete words from search index.
-      Pose.get_words_to_remove(self.pose_words, new_words).each do |word_to_remove|
+      Pose::Helpers.get_words_to_remove(self.pose_words, new_words).each do |word_to_remove|
         self.pose_words.delete word_to_remove
       end
     end

data/lib/pose/models/pose_assignment.rb

@@ -4,10 +4,6 @@ class PoseAssignment < ActiveRecord::Base
   belongs_to :posable, polymorphic: true
   attr_accessible :pose_word, :posable
 
-
-  attr_accessible :pose_word, :posable
-
-
   # Removes all PoseAssignments for the given class.
   def self.delete_class_index clazz
     PoseAssignment.delete_all(['posable_type=?', clazz.name])

data/lib/pose/models/pose_word.rb

@@ -1,14 +1,28 @@
 # A single word in the search index.
 class PoseWord < ActiveRecord::Base
   has_many :pose_assignments
-  attr_accessible :text
 
   attr_accessible :text
 
   def self.remove_unused_words progress_bar = nil
-    PoseWord.find_each(include: [:pose_assignments], batch_size: 5000) do |pose_word|
-      pose_word.delete if pose_word.pose_assignments.size == 0
-      progress_bar.inc if progress_bar
+    if ActiveRecord::Base.connection.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+      # Will generate something like:
+      #
+      # DELETE FROM "pose_words" WHERE "pose_words"."id" IN
+      # (SELECT "pose_words"."id" FROM "pose_words" INNER JOIN "pose_assignments" ON "pose_assignments"."id" = "pose_words"."user_id"
+      # HAVING.... GROUP BY "pose_words"."id")
+      PoseWord.delete_all(id: PoseWord.select("pose_words.id").
+                          joins("LEFT OUTER JOIN pose_assignments ON pose_assignments.pose_word_id = pose_words.id").
+                          group("pose_words.id").
+                          having("COUNT(pose_assignments.id) = 0"))
+    else
+      # NOTE (SZ): do not use find_each uses batch_size == 100.
+      # Use find_in_batches instead.
+      #
+      PoseWord.select(:id).find_in_batches.each(include: [:pose_assignments], batch_size: 5000) do |pose_word|
+        pose_word.delete if pose_word.pose_assignments.size == 0
+        progress_bar.inc if progress_bar
+      end
     end
   end
 end

data/lib/pose/railtie.rb

@@ -7,7 +7,7 @@ module Pose
     # Add the Pose additions to ActiveRecord::Base once it is loaded.
     initializer 'Pose.base_additions' do
       ActiveSupport.on_load :active_record do
-        extend Pose::BaseAdditions
+        extend Pose::ActiveRecordBaseAdditions
       end
     end
 

data/lib/pose/static_api.rb

@@ -0,0 +1,87 @@
+# Static helper methods of the Pose gem. 
+module Pose
+
+  # By default, doesn't run in tests.
+  # Set this to true to test the search functionality.
+  CONFIGURATION = { search_in_tests: false }
+
+  class <<self
+
+    ######################
+    # PUBLIC METHODS
+    #
+
+    # 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 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 = {}
+
+
+      # Get the ids of the results.
+      class_names = Pose::Helpers.make_array(classes).map &:name
+      result_classes_and_ids = {}
+      Pose::Helpers.query_terms(query).each do |query_word|
+        Pose::Helpers.search_classes_and_ids_for_word(query_word, class_names).each do |class_name, ids|
+          Pose::Helpers.merge_search_result_word_matches result_classes_and_ids, class_name, ids
+        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[:scope].blank?
+                # No scope.
+                result[result_class] = ids
+              else
+                # We have a scope.
+                options[:scope].each do |scope|
+                  query = result_class.select('id').where('id IN (?)', ids).where(scope).to_sql
+                  result[result_class] = result_class.connection.select_values(query).map(&:to_i)
+                end
+              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('id IN (?)', ids).where(scope)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/pose/version.rb

@@ -1,3 +1,3 @@
 module Pose
-  VERSION = "1.2.0"
+  VERSION = "1.2.1"
 end

data/spec/internal_helpers_spec.rb

@@ -0,0 +1,178 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Pose::Helpers do
+
+  describe '::get_words_to_add' do
+    let(:one) { PoseWord.new(text: 'one') }
+    let(:two) { PoseWord.new(text: 'two') }
+
+    context 'having a new word to be added' do
+      it 'returns an array with strings that need to be added' do
+        Pose::Helpers.get_words_to_add([one, two], %w{one three}).should eql(['three'])
+      end
+    end
+
+    context 'nothing to add' do
+      it 'returns an empty array' do
+        Pose::Helpers.get_words_to_add([one, two], %w{one two}).should be_empty
+      end
+    end
+  end
+
+
+  describe '::get_words_to_remove' do
+    let(:one) { PoseWord.new(text: 'one') }
+    let(:two) { PoseWord.new(text: 'two') }
+
+    it "returns an array of word objects that need to be removed" do
+      Pose::Helpers.get_words_to_remove([one, two], %w{one three}).should eql([two])
+    end
+
+    it 'returns an empty array if there are no words to be removed' do
+      Pose::Helpers.get_words_to_remove([one, two], %w{one two}).should be_empty
+    end
+  end
+
+
+  describe 'make_array' do
+
+    it 'converts a single value into an array' do
+      Pose::Helpers.make_array(1).should == [1]
+    end
+
+    it 'leaves arrays as arrays' do
+      Pose::Helpers.make_array([1]).should == [1]
+    end
+  end
+
+
+  describe 'merge_search_result_word_matches' do
+    context 'given a new class name' do
+
+      before :each do
+        @result = {}
+      end
+
+      it 'sets the given ids as the ids for this class name' do
+        Pose::Helpers.merge_search_result_word_matches @result, 'class1', [1, 2]
+        @result.should == { 'class1' => [1, 2] }
+      end
+    end
+
+    context 'given a class name with already existing ids from another word' do
+
+      before :each do
+        @result = { 'class1' => [1, 2] }
+      end
+
+      it 'only keeps the ids that are included in both sets' do
+        Pose::Helpers.merge_search_result_word_matches @result, 'class1', [1, 3]
+        @result.should == { 'class1' => [1] }
+      end
+    end
+  end
+
+
+  describe 'query_terms' do
+    it 'returns all individual words resulting from the given query' do
+      Pose::Helpers.query_terms('foo bar').should == ['foo', 'bar']
+    end
+
+    it 'converts the individual words into their root form' do
+      Pose::Helpers.query_terms('bars').should == ['bar']
+    end
+
+    it 'splits complex words into separate terms' do
+      Pose::Helpers.query_terms('one-two').should == ['one', 'two']
+    end
+
+    it 'removes duplicates' do
+      Pose::Helpers.query_terms('foo-bar foo').should == ['foo', 'bar']
+    end
+  end
+
+
+  describe 'root_word' do
+
+    it 'converts words into singular' do
+      Pose::Helpers.root_word('bars').should eql(['bar'])
+    end
+
+    it 'removes special characters' do
+      Pose::Helpers.root_word('(bar').should == ['bar']
+      Pose::Helpers.root_word('bar)').should == ['bar']
+      Pose::Helpers.root_word('(bar)').should == ['bar']
+      Pose::Helpers.root_word('>foo').should == ['foo']
+      Pose::Helpers.root_word('<foo').should == ['foo']
+      Pose::Helpers.root_word('"foo"').should == ['foo']
+      Pose::Helpers.root_word('"foo').should == ['foo']
+      Pose::Helpers.root_word("'foo'").should == ['foo']
+      Pose::Helpers.root_word("'foo's").should == ['foo']
+      Pose::Helpers.root_word("foo?").should == ['foo']
+      Pose::Helpers.root_word("foo!").should == ['foo']
+      Pose::Helpers.root_word("foo/bar").should == ['foo', 'bar']
+      Pose::Helpers.root_word("foo-bar").should == ['foo', 'bar']
+      Pose::Helpers.root_word("foo--bar").should == ['foo', 'bar']
+      Pose::Helpers.root_word("foo.bar").should == ['foo', 'bar']
+    end
+
+    it 'removes umlauts' do
+      Pose::Helpers.root_word('fünf').should == ['funf']
+    end
+
+    it 'splits up numbers' do
+      Pose::Helpers.root_word('11.2.2011').should == ['11', '2', '2011']
+      Pose::Helpers.root_word('11-2-2011').should == ['11', '2', '2011']
+      Pose::Helpers.root_word('30:4-5').should == ['30', '4', '5']
+    end
+
+    it 'converts into lowercase' do
+      Pose::Helpers.root_word('London').should == ['london']
+    end
+
+    it "stores single-letter words" do
+      Pose::Helpers.root_word('a b').should == ['a', 'b']
+    end
+
+    it "does't encode external URLs" do
+      Pose::Helpers.root_word('http://web.com').should == ['http', 'web', 'com']
+    end
+
+    it "doesn't store empty words" do
+      Pose::Helpers.root_word('  one two  ').should == ['one', 'two']
+    end
+
+    it "removes duplicates" do
+      Pose::Helpers.root_word('one_one').should == ['one']
+      Pose::Helpers.root_word('one one').should == ['one']
+    end
+
+    it "splits up complex URLs" do
+      Pose::Helpers.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_classes_and_ids_for_word' do
+
+    it 'returns a hash that contains all the given classes' do
+      result = Pose::Helpers.search_classes_and_ids_for_word 'foo', %w{PosableOne PosableTwo}
+      result.keys.sort.should == %w{PosableOne PosableTwo}
+    end
+
+    it 'returns the ids of all the posable objects that include the given word' do
+      pos1 = PosableOne.create text: 'one two'
+      pos2 = PosableTwo.create text: 'one three'
+      pos3 = PosableTwo.create text: 'two three'
+
+      result = Pose::Helpers.search_classes_and_ids_for_word 'one', %w{PosableOne PosableTwo}
+
+      result['PosableOne'].should == [pos1.id]
+      result['PosableTwo'].should == [pos2.id]
+    end
+  end
+end
+