search_magic 0.0.2 → 0.0.3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    search_magic (0.0.1)
+    search_magic (0.0.2)
       mongoid (>= 2.0.0.rc.7)
 
 GEM

data/lib/search_magic/full_text_search.rb

@@ -9,20 +9,11 @@ module SearchMagic
       end
       
       def search_on(field_name, options = {})
-        metadata = reflect_on_association(field_name)
-        send(:searchable_fields)[field_name] = Metadata.new(:field_name => field_name, :field => fields[field_name.to_s], :association => metadata, :options => options)
+        searchable_fields[field_name] = options
       end
       
       def searchables
-        @searchables ||= Hash[*searchable_fields.values.map {|metadata| metadata.searchable_names(nil).map {|a| [a.first, a.last]}}.flatten].tap do |hash|
-          hash.keys.each do |name|
-            if self.method_defined?(name) && reflect_on_association(name).nil?
-              alias_method(:"_#{name}", name)
-            else
-              define_method(:"_#{name}") {find_searchable_value(name)}
-            end
-          end
-        end
+        @searchables ||= create_searchables
       end
       
       def search(pattern)
@@ -39,13 +30,36 @@ module SearchMagic
           criteria
         end
       end
+      
+      private 
+      
+      def create_searchables
+        fields = searchable_fields.map do |field_name, options|
+          if association = reflect_on_association(field_name)
+            options[:as] ||= nil
+            only = [options[:only]].flatten.compact
+            except = [options[:except]].flatten.compact
+            associated = association.class_name.constantize.searchables.reject {|key, value| except.include?(key) }.select {|key, value| only.blank? ? true : only.include?(key) }
+            associated.map do |name, metadata|
+              Metadata.new(:type => self, :through => lambda do |obj|
+                value = obj.send(field_name)
+                value.is_a?(Array) ? value.map {|item| metadata.through.call(item)} : metadata.through.call(value)
+              end, :prefix => field_name.to_s.singularize.to_sym, :field_name => name, :options => metadata.options.merge(options))
+            end
+          else
+            Metadata.new(:type => self, :through => lambda {|obj| obj.send(field_name) }, :field_name => field_name.to_s.pluralize.singularize.to_sym, :options => options)
+          end
+        end.flatten
+        
+        Hash[*fields.map {|metadata| [metadata.name, metadata]}.flatten]
+      end
     end
   
     module InstanceMethods
       private
       
       def update_searchable_values
-        send :searchable_values=, self.searchable_fields.values.map {|metadata| metadata.searchable_value(self)}.flatten
+        self.searchable_values = self.class.searchables.values.map {|metadata| metadata.searchable_value_for(self)}.flatten
       end
       
       def find_searchable_value(name)
@@ -55,44 +69,28 @@ module SearchMagic
     end
     
     class Metadata
-      attr_accessor :field_name, :field, :association, :options
+      attr_accessor :type, :through, :prefix, :field_name, :options
 
       def initialize(attributes = {})
         attributes.each do |key, value|
           send(:"#{key}=", value)
         end
-        options[:only] = [options[:only]].flatten.compact
-        options[:except] = [options[:except]].flatten.compact
       end
       
-      def searchable_value(model)
-        searchable_names(model).map {|searchable_name, value, sub_name, options| value_for(searchable_name, value, sub_name, options)}
+      def name
+        @name ||= [options[:skip_prefix].presence ? nil : (prefix.present? ? options[:as] || prefix : nil), 
+                  prefix.present? ? field_name : (options[:as] || field_name)].compact.join("_").to_sym
       end
       
-      def searchable_names(model)
-        name = options[:skip_prefix].presence ? nil : (options[:as] || self.field_name)
-        value = model.present? ? model.send(self.field_name) : nil
-        sub_fields = self.association.class_name.constantize.searchables if self.association
-        fields = (sub_fields.keys - options[:except]) & (options[:only].blank? ? sub_fields.keys : options[:only]) if sub_fields
-        case self.association.try(:macro)
-        when nil
-          [[self.field.type == Array ? name.to_s.singularize.to_sym : name, value, nil, self.options]]
-        when :embedded_in, :embeds_one, :referenced_in, :references_one
-          fields.map {|sub_name| [create_nested_name(name, sub_name), value, sub_name, self.options.merge(sub_fields[sub_name])]}
-        else
-          fields.map {|sub_name| [create_nested_name(name.to_s.singularize, sub_name.to_s.pluralize), value, sub_name, self.options.merge(sub_fields[sub_name])]}
-        end
-      end
-      
-      def create_nested_name(owning_name, sub_name)
-        [owning_name, sub_name].compact.join("_").to_sym
+      def value_for(obj)
+        v = self.through.call(obj)
+        v = v.is_a?(Array) ? v.join(" ") : v.to_s
+        v = v.gsub(/[[:punct:]]/, ' ') unless options[:keep_punctuation]
+        v
       end
       
-      def value_for(searchable_name, value, field_name, options)
-        v = field_name.present? && value.present? ? [value].flatten.map{|i| i.send("_#{field_name}")} : value
-        v = v.is_a?(Array) ? v.join(" ") : v.to_s
-        v = v.gsub(/[[:punct:]]/, '') unless options[:keep_punctuation]
-        v.downcase.split.map {|word| [searchable_name, word].join(":")}
+      def searchable_value_for(obj)
+        value_for(obj).downcase.split.map {|word| [name, word].join(":")}
       end
     end
   

data/lib/search_magic/version.rb

@@ -1,3 +1,3 @@
 module SearchMagic
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/unit/search_magic/associations_spec.rb

@@ -6,13 +6,14 @@ describe SearchMagic::FullTextSearch do
     it { subject.searchable_fields.keys.should include(:address) }
     it { subject.searchable_fields.keys.should include(:phones) }
     it { should respond_to(:searchables)}
-    its(:searchables) { should include(:address_street, :address_city, :address_state, :address_post_code, :mobile_numbers)}
+    its("searchables.keys") { should include(:address_street, :address_city, :address_state, :address_post_code, :mobile_number)}
+    its("searchables.keys") { should_not include(:mobile_country_code)}
   end
   
   describe "model includes referenced document fields in :searchable_fields" do
     subject { Part }
     it { subject.searchable_fields.keys.should include(:part_number) }
-    its(:searchables) { should include(:part_number, :category_name) }
+    its("searchables.keys") { should include(:part_number, :category_name) }
   end
   
   context "when a model embeds one other document" do
@@ -26,12 +27,6 @@ describe SearchMagic::FullTextSearch do
       its(:address) { should_not be_nil }
       its(:phones) { should_not be_empty }
       its(:searchable_values) { should include("address_street:123", "address_street:example", "address_street:st") }
-      it { should respond_to(:_address_street, :_address_city, :_address_state, :_address_post_code, :_mobile_numbers)}
-      its(:_address_street) { should include("123", "example", "st") }
-      its(:_address_state) { should == "ca" }
-      its(:_address_city) { should == "nowhereland" }
-      its(:_address_post_code) { should == "12345" }
-      its(:_mobile_numbers) { should include("555-1234", "333-7890") }
     end
     
     context "when searching for 'address_city:nowhereland'" do
@@ -46,6 +41,23 @@ describe SearchMagic::FullTextSearch do
       its(:count) { should == 1 }
       its("first.name") { should == "Samuel" }
     end
+    
+    context "when searching for 'mobile_number:555-'" do
+      subject { Person.search("mobile_number:555-") }
+      its(:count) { should == 2 }
+    end
+    
+    context "when searching for 'mobile_number:333-'" do
+      subject { Person.search("mobile_number:333-") }
+      its(:count) { should == 1 }
+      its("first.name") { should == "Joshua" }
+    end
+    
+    context "when searching for 'mobile_number:-0987'" do
+      subject { Person.search("mobile_number:-0987") }
+      its(:count) { should == 1 }
+      its("first.name") { should == "Samuel" }
+    end
   end
   
   context "when a model references other documents" do
@@ -100,10 +112,6 @@ describe SearchMagic::FullTextSearch do
         it { should be }
         its(:part_number) { should_not be_nil }
         its(:searchable_values) { should include("part_number:t11001", "category_name:table", "status:available", "serial:t0411001") }
-        its(:_part_number) { should == "t11001" }
-        its(:_category_name) { should == "table" }
-        its(:_status) { should == "available" }
-        its(:_serial) { should == "T0411001" }
       end
       
       context "when searching for 'category_name:table'" do

data/spec/unit/search_magic/fields_spec.rb

@@ -25,8 +25,8 @@ describe SearchMagic::FullTextSearch do
     its("searchable_fields.keys") { should include(:title, :description, :tags) }
     its("searchable_fields.keys") { should_not include(:uuid) }
     
-    its(:searchables) { should include(:title, :description, :tag) }
-    its(:searchables) { should_not include(:uuid) }
+    its("searchables.keys") { should include(:title, :description, :tag) }
+    its("searchables.keys") { should_not include(:uuid) }
   end
   
   describe "saving a model should run the :update_searchable_values callback" do

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Joshua Bowers