pg_search 0.0.2 → 0.1

data/.gitignore

@@ -1,7 +1,8 @@
 pkg/*
+doc
 *.gem
 .bundle
 .idea
 tags
 *~
-gemfiles/**/Gemfile.lock
+gemfiles/**/Gemfile.lock

data/CHANGELOG

@@ -1,3 +1,9 @@
+### 0.1
+
+Change API to {:ignoring => :accents} from {:normalizing => :diacritics}
+Improve documentation
+Fix bug where :associated_against would not work without an :against present
+
 ### 0.0.2
 
 Fix gem ownership.

data/README.rdoc

@@ -2,11 +2,11 @@
 
 * http://github.com/casecommons/pg_search/
 
-== DESCRIPTION:
+== DESCRIPTION
 
 PgSearch builds named scopes that take advantage of PostgreSQL's full text search
 
-== INSTALL:
+== INSTALL
 
  gem install pg_search
 
@@ -99,10 +99,10 @@ Important: The returned hash must include a :query key. Its value does not neces
 You can pass a Hash into the :associated_against option to search columns on other models. The keys are the names of the associations and the value works just like an :against option for the other model.
 
   class Cracker < ActiveRecord::Base
+    has_many :cheeses
   end
 
   class Cheese < ActiveRecord::Base
-    has_many :cheeses
   end
 
   class Salami < ActiveRecord::Base
@@ -279,12 +279,33 @@ Trigram support is currently available as part of the {pg_trgm contrib package}[
 
   Website.kinda_spelled_like("Yahoo!") # => [yahooo, yohoo]
 
+=== Ignoring accent marks
+
+Most of the time you will want to ignore accent marks when searching. This makes it possible to find words like "piñata" when searching with the query "pinata". If you set a pg_search_scope to ignore accents, it will ignore accents in both the searchable text and the query terms.
+
+Ignoring accents uses the {unaccent contrib package}[http://www.postgresql.org/docs/current/static/unaccent.html] that must be installed before this feature can be used.
+
+
+  class SpanishQuestion < ActiveRecord::Base
+    include PgSearch
+    pg_search_scope :gringo_search,
+                    :against => :word,
+                    :ignoring => :accents
+  end
+
+  what = SpanishQuestion.create(:word => "Qué")
+  how_many = SpanishQuestion.create(:word => "Cuánto")
+  how = SpanishQuestion.create(:word => "Cómo")
+
+  SpanishQuestion.gringo_search("Que") # => [what]
+  SpanishQuestion.gringo_search("Cüåñtô") # => [how_many]
+
 == REQUIREMENTS
 
 * ActiveRecord 2 or 3
 * Postgresql
 * Postgresql contrib modules for certain features
 
-== LICENSE:
+== LICENSE
 
 MIT

data/Rakefile

@@ -33,3 +33,10 @@ namespace "autotest" do
     end
   end
 end
+
+namespace "doc" do
+  desc "Generate README and preview in browser"
+  task "readme" do
+    sh "rdoc -c utf8 README.rdoc && open doc/files/README_rdoc.html"
+  end
+end

data/lib/pg_search/configuration.rb

@@ -14,6 +14,7 @@ module PgSearch
     end
 
     def regular_columns
+      return [] unless @options[:against]
       Array(@options[:against]).map do |column_name, weight|
         Column.new(column_name, weight, @model)
       end
@@ -32,8 +33,8 @@ module PgSearch
       @options[:query].to_s
     end
 
-    def normalizations
-      Array.wrap(@options[:normalizing])
+    def ignore
+      Array.wrap(@options[:ignoring])
     end
 
     def ranking_sql
@@ -51,12 +52,14 @@ module PgSearch
     end
 
     def assert_valid_options(options)
-      valid_keys = [:against, :ranked_by, :normalizing, :using, :query, :associated_against]
+      valid_keys = [:against, :ranked_by, :ignoring, :using, :query, :associated_against]
       valid_values = {
-        :normalizing => [:diacritics]
+        :ignoring => [:accents]
       }
 
-      raise ArgumentError, "the search scope #{@name} must have :against in its options" unless options[:against]
+      unless options[:against] || options[:associated_against]
+        raise ArgumentError, "the search scope #{@name} must have :against#{" or :associated_against" if defined?(ActiveRecord::Relation)} in its options"
+      end
       raise ArgumentError, ":associated_against requires ActiveRecord 3 or later" if options[:associated_against] && !defined?(ActiveRecord::Relation)
 
       options.assert_valid_keys(valid_keys)

data/lib/pg_search/normalizer.rb

@@ -6,7 +6,7 @@ module PgSearch
 
     def add_normalization(original_sql)
       normalized_sql = original_sql
-      normalized_sql = "unaccent(#{normalized_sql})" if @config.normalizations.include?(:diacritics)
+      normalized_sql = "unaccent(#{normalized_sql})" if @config.ignore.include?(:accents)
       normalized_sql
     end
   end

data/lib/pg_search/version.rb

@@ -1,3 +1,3 @@
 module PgSearch
-  VERSION = "0.0.2"
+  VERSION = "0.1"
 end

data/spec/associations_spec.rb

@@ -4,6 +4,43 @@ describe PgSearch do
   context "joining to another table" do
     if defined?(ActiveRecord::Relation)
       context "with Arel support" do
+        context "without an :against" do
+          with_model :associated_model do
+            table do |t|
+              t.string "title"
+            end
+          end
+
+          with_model :model_without_against do
+            table do |t|
+              t.string "title"
+              t.belongs_to :another_model
+            end
+
+            model do
+              include PgSearch
+              belongs_to :another_model, :class_name => 'AssociatedModel'
+
+              pg_search_scope :with_another, :associated_against => {:another_model => :title}
+            end
+          end
+
+          it "returns rows that match the query in the columns of the associated model only" do
+            associated = associated_model.create!(:title => 'abcdef')
+            included = [
+              model_without_against.create!(:title => 'abcdef', :another_model => associated),
+              model_without_against.create!(:title => 'ghijkl', :another_model => associated)
+            ]
+            excluded = [
+              model_without_against.create!(:title => 'abcdef')
+            ]
+
+            results = model_without_against.with_another('abcdef')
+            results.map(&:title).should =~ included.map(&:title)
+            results.should_not include(excluded)
+          end
+        end
+
         context "through a belongs_to association" do
           with_model :associated_model do
             table do |t|

data/spec/pg_search_spec.rb

@@ -88,24 +88,24 @@ describe "an ActiveRecord model which includes PgSearch" do
       end
     end
 
-    context "when an unknown :normalizing is passed" do
+    context "when an unknown :ignoring is passed" do
       it "raises an exception when invoked" do
         lambda {
           model_with_pg_search.class_eval do
-            pg_search_scope :with_unknown_normalizing, :against => :content, :normalizing => :foo
+            pg_search_scope :with_unknown_ignoring, :against => :content, :ignoring => :foo
           end
-          model_with_pg_search.with_unknown_normalizing("foo")
-        }.should raise_error(ArgumentError, /normalizing.*foo/)
+          model_with_pg_search.with_unknown_ignoring("foo")
+        }.should raise_error(ArgumentError, /ignoring.*foo/)
       end
 
       context "dynamically" do
         it "raises an exception when invoked" do
           lambda {
             model_with_pg_search.class_eval do
-              pg_search_scope :with_unknown_normalizing, lambda { |*| {:against => :content, :normalizing => :foo} }
+              pg_search_scope :with_unknown_ignoring, lambda { |*| {:against => :content, :ignoring => :foo} }
             end
-            model_with_pg_search.with_unknown_normalizing("foo")
-          }.should raise_error(ArgumentError, /normalizing.*foo/)
+            model_with_pg_search.with_unknown_ignoring("foo")
+          }.should raise_error(ArgumentError, /ignoring.*foo/)
         end
       end
 
@@ -113,18 +113,18 @@ describe "an ActiveRecord model which includes PgSearch" do
         it "raises an exception when invoked" do
           lambda {
             model_with_pg_search.class_eval do
-              pg_search_scope :with_unknown_normalizing, {}
+              pg_search_scope :with_unknown_ignoring, {}
             end
-            model_with_pg_search.with_unknown_normalizing("foo")
+            model_with_pg_search.with_unknown_ignoring("foo")
           }.should raise_error(ArgumentError, /against/)
         end
         context "dynamically" do
           it "raises an exception when invoked" do
             lambda {
               model_with_pg_search.class_eval do
-                pg_search_scope :with_unknown_normalizing, lambda { |*| {} }
+                pg_search_scope :with_unknown_ignoring, lambda { |*| {} }
               end
-              model_with_pg_search.with_unknown_normalizing("foo")
+              model_with_pg_search.with_unknown_ignoring("foo")
             }.should raise_error(ArgumentError, /against/)
           end
         end
@@ -177,7 +177,7 @@ describe "an ActiveRecord model which includes PgSearch" do
         results.should =~ included
       end
 
-      it "returns rows that match the query only if their diacritics match" do
+      it "returns rows that match the query only if their accents match" do
         # \303\241 is a with acute accent
         # \303\251 is e with acute accent
 
@@ -513,20 +513,20 @@ describe "an ActiveRecord model which includes PgSearch" do
       end
     end
 
-    context "normalizing diacritics" do
+    context "ignoring accents" do
       before do
         model_with_pg_search.class_eval do
-          pg_search_scope :search_title_without_diacritics, :against => :title, :normalizing => :diacritics
+          pg_search_scope :search_title_without_accents, :against => :title, :ignoring => :accents
         end
       end
 
-      it "returns rows that match the query but not its diacritics" do
+      it "returns rows that match the query but not its accents" do
         # \303\241 is a with acute accent
         # \303\251 is e with acute accent
 
         included = model_with_pg_search.create!(:title => "\303\241bcdef")
 
-        results = model_with_pg_search.search_title_without_diacritics("abcd\303\251f")
+        results = model_with_pg_search.search_title_without_accents("abcd\303\251f")
         results.should == [included]
       end
     end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: pg_search
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 9
   prerelease: false
   segments: 
   - 0
-  - 0
-  - 2
-  version: 0.0.2
+  - 1
+  version: "0.1"
 platform: ruby
 authors: 
 - Case Commons, LLC
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-14 00:00:00 -05:00
+date: 2011-01-18 00:00:00 -05:00
 default_executable: 
 dependencies: []