scoped_search 2.2.1 → 2.3.0

data/lib/scoped_search/rails_helper.rb

@@ -0,0 +1,210 @@
+module ScopedSearch
+  module RailsHelper
+    # Creates a link that alternates between ascending and descending.
+    #
+    # Examples:
+    #
+    #   sort @search, :by => :username
+    #   sort @search, :by => :created_at, :as => "Created"
+    #
+    # This helper accepts the following options:
+    #
+    # * <tt>:by</tt> - the name of the named scope. This helper will prepend this value with "ascend_by_" and "descend_by_"
+    # * <tt>:as</tt> - the text used in the link, defaults to whatever is passed to :by
+    def sort(field, options = {}, html_options = {})
+
+      unless options[:as]
+        id           = field.to_s.downcase == "id"
+        options[:as] = id ? field.to_s.upcase : field.to_s.humanize
+      end
+
+      ascend  = "#{field} ASC"
+      descend = "#{field} DESC"
+
+      ascending = params[:order] == ascend
+      new_sort = ascending ? descend : ascend
+      selected = [ascend, descend].include?(params[:order])
+
+      if selected
+        css_classes = html_options[:class] ? html_options[:class].split(" ") : []
+        if ascending
+          options[:as] = "&#9650;&nbsp;#{options[:as]}"
+          css_classes << "ascending"
+        else
+          options[:as] = "&#9660;&nbsp;#{options[:as]}"
+          css_classes << "descending"
+        end
+        html_options[:class] = css_classes.join(" ")
+      end
+
+      url_options = params.merge(:order => new_sort)
+
+      options[:as] = raw(options[:as]) if defined?(RailsXss)
+
+      a_link(options[:as], html_escape(url_for(url_options)),html_options)
+    end
+
+    # Adds AJAX auto complete functionality to the text input field with the
+    # DOM ID specified by +field_id+.
+    #
+    # Required   +options+ is:
+    # <tt>:url</tt>::                  URL to call for auto completion results
+    #                                  in url_for format.
+    #
+    # Additional +options+ are:
+    # <tt>:update</tt>::               Specifies the DOM ID of the element whose
+    #                                  innerHTML should be updated with the auto complete
+    #                                  entries returned by the AJAX request.
+    #                                  Defaults to <tt>field_id</tt> + '_auto_complete'
+    # <tt>:with</tt>::                 A JavaScript expression specifying the
+    #                                  parameters for the XMLHttpRequest. This defaults
+    #                                  to 'fieldname=value'.
+    # <tt>:frequency</tt>::            Determines the time to wait after the last keystroke
+    #                                  for the AJAX request to be initiated.
+    # <tt>:indicator</tt>::            Specifies the DOM ID of an element which will be
+    #                                  displayed while auto complete is running.
+    # <tt>:tokens</tt>::               A string or an array of strings containing
+    #                                  separator tokens for tokenized incremental
+    #                                  auto completion. Example: <tt>:tokens => ','</tt> would
+    #                                  allow multiple auto completion entries, separated
+    #                                  by commas.
+    # <tt>:min_chars</tt>::            The minimum number of characters that should be
+    #                                  in the input field before an Ajax call is made
+    #                                  to the server.
+    # <tt>:on_hide</tt>::              A Javascript expression that is called when the
+    #                                  auto completion div is hidden. The expression
+    #                                  should take two variables: element and update.
+    #                                  Element is a DOM element for the field, update
+    #                                  is a DOM element for the div from which the
+    #                                  innerHTML is replaced.
+    # <tt>:on_show</tt>::              Like on_hide, only now the expression is called
+    #                                  then the div is shown.
+    # <tt>:after_update_element</tt>:: A Javascript expression that is called when the
+    #                                  user has selected one of the proposed values.
+    #                                  The expression should take two variables: element and value.
+    #                                  Element is a DOM element for the field, value
+    #                                  is the value selected by the user.
+    # <tt>:select</tt>::               Pick the class of the element from which the value for
+    #                                  insertion should be extracted. If this is not specified,
+    #                                  the entire element is used.
+    # <tt>:method</tt>::               Specifies the HTTP verb to use when the auto completion
+    #                                  request is made. Defaults to POST.
+    def auto_complete_field(field_id, options = {})
+      function =  "var #{field_id}_auto_completer = new Ajax.Autocompleter("
+      function << "'#{field_id}', "
+      function << "'" + (options[:update] || "#{field_id}_auto_complete") + "', "
+      function << "'#{url_for(options[:url])}'"
+
+      js_options = {}
+      js_options[:tokens] = array_or_string_for_javascript(options[:tokens])            if options[:tokens]
+      js_options[:callback]   = "function(element, value) { return #{options[:with]} }" if options[:with]
+      js_options[:indicator]  = "'#{options[:indicator]}'"                              if options[:indicator]
+      js_options[:select]     = "'#{options[:select]}'"                                 if options[:select]
+      js_options[:paramName]  = "'#{options[:param_name]}'"                             if options[:param_name]
+      js_options[:frequency]  = "#{options[:frequency]}"                                if options[:frequency]
+      js_options[:method]     = "'#{options[:method].to_s}'"                            if options[:method]
+
+      { :after_update_element => :afterUpdateElement,
+        :on_show => :onShow, :on_hide => :onHide, :min_chars => :minChars }.each do |k,v|
+        js_options[v] = options[k] if options[k]
+      end
+
+      function << (', ' + options_for_javascript(js_options) + ')')
+
+      javascript_tag(function)
+    end
+
+    def auto_complete_field_jquery(method, url, options = {})
+      function = <<-EOF
+      $.widget( "custom.catcomplete", $.ui.autocomplete, {
+        _renderMenu: function( ul, items ) {
+          var self = this,
+          currentCategory = "";
+          $.each( items, function( index, item ) {
+            if ( item.category != undefined && item.category != currentCategory ) {
+              ul.append( "<li class='ui-autocomplete-category'>" + item.category + "</li>" );
+              currentCategory = item.category;
+            }
+            if ( item.error != undefined ) {
+              ul.append( "<li class='ui-autocomplete-error'>" + item.error + "</li>" );
+            }
+            if( item.completed != undefined ) {
+              $( "<li></li>" ).data( "item.autocomplete", item )
+				      .append( "<a>" + "<strong class='ui-autocomplete-completed'>" + item.completed + "</strong>" + item.part + "</a>" )
+				      .appendTo( ul );
+            } else {
+              self._renderItem( ul, item );
+            }
+          });
+        }
+      });
+
+      $("##{method}")
+      .catcomplete({
+			source: function( request, response ) {	$.getJSON( "#{url}", { #{method}: request.term }, response );	},
+			minLength: #{options[:min_length] || 0},
+      delay: #{options[:delay] || 200},
+      select: function(event, ui) { $( this ).catcomplete( "search" , ui.item.value); },
+      search: function(event, ui) { $(".auto_complete_clear").hide(); },
+      open: function(event, ui) { $(".auto_complete_clear").show(); }
+      });
+
+      $("##{method}").bind( "focus", function( event ) {
+        if( $( this )[0].value == "" ) {
+					$( this ).catcomplete( "search" );
+        }
+			});
+
+ EOF
+
+
+      javascript_tag(function)
+    end
+
+    def auto_complete_clear_value_button(field_id)
+      html_options = {:tabindex => '-1',:class=>"auto_complete_clear",:title =>'Clear Search', :onclick=>"document.getElementById('#{field_id}').value = '';"}
+      a_link("", "#", html_options)
+    end
+
+    def a_link(name, href, html_options)
+      tag_options = tag_options(html_options)
+      link = "<a href=\"#{href}\"#{tag_options}>#{name}</a>"
+      return link.respond_to?(:html_safe) ? link.html_safe : link
+    end
+
+    # Use this method in your view to generate a return for the AJAX auto complete requests.
+    #
+    # The auto_complete_result can of course also be called from a view belonging to the
+    # auto_complete action if you need to decorate it further.
+    def auto_complete_result(entries, phrase = nil)
+      return unless entries
+      items = entries.map { |entry| content_tag("li", phrase ? highlight(entry, phrase) : h(entry)) }
+      content_tag("ul", items)
+    end
+
+    # Wrapper for text_field with added AJAX auto completion functionality.
+    #
+    # In your controller, you'll need to define an action called
+    # auto_complete_method to respond the AJAX calls,
+    def auto_complete_field_tag(method, val,tag_options = {}, completion_options = {})
+      auto_completer_options = { :url => { :action => "auto_complete_#{method}" } }.update(completion_options)
+
+      text_field_tag(method, val,tag_options.merge(:class => "auto_complete_input")) +
+          auto_complete_clear_value_button(method) +
+          content_tag("div", "", :id => "#{method}_auto_complete", :class => "auto_complete") +
+          auto_complete_field(method, auto_completer_options)
+    end
+
+    # Wrapper for text_field with added JQuery auto completion functionality.
+    #
+    # In your controller, you'll need to define an action called
+    # auto_complete_method to respond the JQuery calls,
+    def auto_complete_field_tag_jquery(method, val,tag_options = {}, completion_options = {})
+      url = url_for(:action => "auto_complete_#{method}")
+      options = tag_options.merge(:class => "auto_complete_input")
+      text_field_tag(method, val, options) + auto_complete_clear_value_button(method) +
+          auto_complete_field_jquery(method, url, completion_options)
+    end
+
+  end
+end

data/lib/scoped_search.rb

@@ -1,3 +1,5 @@
+require 'active_record'
+
 # ScopedSearch is the base module for the scoped_search plugin. This file
 # defines some modules and exception classes, loads the necessary files, and
 # installs itself in ActiveRecord.
@@ -12,7 +14,7 @@ module ScopedSearch
 
   # The current scoped_search version. Do not change thisvalue by hand,
   # because it will be updated automatically by the gem release script.
-  VERSION = "2.2.1"
+  VERSION = "2.3.0"
 
   # The ClassMethods module will be included into the ActiveRecord::Base class
   # to add the <tt>ActiveRecord::Base.scoped_search</tt> method and the
@@ -85,7 +87,13 @@ end
 require 'scoped_search/definition'
 require 'scoped_search/query_language'
 require 'scoped_search/query_builder'
+require 'scoped_search/auto_complete_builder'
 
 # Import the search_on method in the ActiveReocrd::Base class
 ActiveRecord::Base.send(:extend, ScopedSearch::ClassMethods)
 ActiveRecord::Base.send(:extend, ScopedSearch::BackwardsCompatibility)
+
+if defined?(ActionController)
+  require "scoped_search/rails_helper"
+  ActionController::Base.helper(ScopedSearch::RailsHelper)
+end

data/scoped_search.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
   
   # Do not change the version and date fields by hand. This will be done
   # automatically by the gem release script.
-  s.version = "2.2.1"
-  s.date    = "2010-11-09"
+  s.version = "2.3.0"
+  s.date    = "2011-05-16"
 
   s.summary = "Easily search you ActiveRecord models with a simple query language using a named scope."
   s.description = <<-EOS
@@ -26,12 +26,14 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency('activerecord', '>= 2.1.0')
   s.add_development_dependency('rspec', '~> 2.0')
+  
+  s.add_development_dependency('sqlite3-ruby')  
 
   s.rdoc_options << '--title' << s.name << '--main' << 'README.rdoc' << '--line-numbers' << '--inline-source'
   s.extra_rdoc_files = ['README.rdoc']
 
   # Do not change the files and test_files fields by hand. This will be done
   # automatically by the gem release script.
-  s.files      = %w(.gitignore LICENSE README.rdoc Rakefile init.rb lib/scoped_search.rb lib/scoped_search/definition.rb lib/scoped_search/query_builder.rb lib/scoped_search/query_language.rb lib/scoped_search/query_language/ast.rb lib/scoped_search/query_language/parser.rb lib/scoped_search/query_language/tokenizer.rb scoped_search.gemspec spec/database.yml spec/integration/api_spec.rb spec/integration/ordinal_querying_spec.rb spec/integration/profile_querying_spec.rb spec/integration/relation_querying_spec.rb spec/integration/string_querying_spec.rb spec/lib/database.rb spec/lib/matchers.rb spec/lib/mocks.rb spec/spec_helper.rb spec/unit/ast_spec.rb spec/unit/definition_spec.rb spec/unit/parser_spec.rb spec/unit/query_builder_spec.rb spec/unit/tokenizer_spec.rb tasks/github-gem.rake)
-  s.test_files = %w(spec/integration/api_spec.rb spec/integration/ordinal_querying_spec.rb spec/integration/profile_querying_spec.rb spec/integration/relation_querying_spec.rb spec/integration/string_querying_spec.rb spec/unit/ast_spec.rb spec/unit/definition_spec.rb spec/unit/parser_spec.rb spec/unit/query_builder_spec.rb spec/unit/tokenizer_spec.rb)
-end
+  s.files      = %w(.gitignore .infinity_test Gemfile LICENSE README.rdoc Rakefile init.rb lib/scoped_search.rb lib/scoped_search/auto_complete_builder.rb lib/scoped_search/definition.rb lib/scoped_search/query_builder.rb lib/scoped_search/query_language.rb lib/scoped_search/query_language/ast.rb lib/scoped_search/query_language/parser.rb lib/scoped_search/query_language/tokenizer.rb lib/scoped_search/rails_helper.rb scoped_search.gemspec spec/database.yml spec/integration/api_spec.rb spec/integration/auto_complete_spec.rb spec/integration/key_value_querying_spec.rb spec/integration/ordinal_querying_spec.rb spec/integration/profile_querying_spec.rb spec/integration/relation_querying_spec.rb spec/integration/set_query_spec.rb spec/integration/string_querying_spec.rb spec/lib/database.rb spec/lib/matchers.rb spec/lib/mocks.rb spec/spec_helper.rb spec/unit/ast_spec.rb spec/unit/auto_complete_builder_spec.rb spec/unit/definition_spec.rb spec/unit/parser_spec.rb spec/unit/query_builder_spec.rb spec/unit/tokenizer_spec.rb tasks/github-gem.rake)
+  s.test_files = %w(spec/integration/api_spec.rb spec/integration/auto_complete_spec.rb spec/integration/key_value_querying_spec.rb spec/integration/ordinal_querying_spec.rb spec/integration/profile_querying_spec.rb spec/integration/relation_querying_spec.rb spec/integration/set_query_spec.rb spec/integration/string_querying_spec.rb spec/unit/ast_spec.rb spec/unit/auto_complete_builder_spec.rb spec/unit/definition_spec.rb spec/unit/parser_spec.rb spec/unit/query_builder_spec.rb spec/unit/tokenizer_spec.rb)
+end

data/spec/database.yml

@@ -7,13 +7,20 @@
 # to you.
 
 
-<% if Gem.available?('sqlite3-ruby') %>
-sqlite3:
-  adapter: "sqlite3"
-  database: ":memory:"
-<% end %>
+# <% if Gem.available?('sqlite3-ruby') %>
+# sqlite3:
+#   adapter: "sqlite3"
+#   database: ":memory:"
+# <% end %>
 
-<% if Gem.available?('mysql') %>
+<% if Gem.available?('mysql2') %>
+mysql2:
+  adapter: "mysql2"
+  host: "localhost"
+  username: "root"
+  password:
+  database: "scoped_search_test"
+<% elsif Gem.available?('mysql') %>
 mysql:
   adapter: "mysql"
   host: "localhost"

data/spec/integration/api_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "#{File.dirname(__FILE__)}/../spec_helper"
 
 describe ScopedSearch, "API" do
 

data/spec/integration/auto_complete_spec.rb

@@ -0,0 +1,140 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+# These specs will run on all databases that are defined in the spec/database.yml file.
+# Comment out any databases that you do not have available for testing purposes if needed.
+ScopedSearch::RSpec::Database.test_databases.each do |db|
+
+  describe ScopedSearch, "using a #{db} database" do
+
+    before(:all) do
+      ScopedSearch::RSpec::Database.establish_named_connection(db)
+
+      ## The related class
+      ActiveRecord::Migration.drop_table(:bars) rescue nil
+      ActiveRecord::Migration.create_table(:bars) { |t| t.string :related; t.integer :foo_id }
+      class ::Bar < ActiveRecord::Base; belongs_to :foo; end
+
+      ::Foo = ScopedSearch::RSpec::Database.create_model(:string => :string, :another => :string, :explicit => :string, :int => :integer, :date => :date, :unindexed => :integer) do |klass|
+        klass.has_many :bars
+        
+        klass.scoped_search :on => [:string, :int, :date]
+        klass.scoped_search :on => :another,  :default_operator => :eq, :alias => :alias
+        klass.scoped_search :on => :explicit, :only_explicit => true, :complete_value => true
+        klass.scoped_search :on => :related, :in => :bars, :rename => 'bars.related'.to_sym
+        
+      end
+
+      @foo_1 = Foo.create!(:string => 'foo', :another => 'temp 1', :explicit => 'baz', :int => 9  , :date => 'February 8, 20011' , :unindexed => 10)
+      Foo.create!(:string => 'bar', :another => 'temp 2', :explicit => 'baz', :int => 9  , :date => 'February 10, 20011', :unindexed => 10)
+      Foo.create!(:string => 'baz', :another => nil,      :explicit => nil  , :int => nil, :date => nil                 , :unindexed => nil)
+
+      Bar.create!(:related => 'lala',         :foo => @foo_1)
+      Bar.create!(:related => 'another lala', :foo => @foo_1)
+    end
+
+    after(:all) do
+      ScopedSearch::RSpec::Database.drop_model(Foo)
+      ScopedSearch::RSpec::Database.drop_model(Bar)
+      ScopedSearch::RSpec::Database.close_connection
+    end
+
+    context 'basic auto completer' do
+      it "should complete the field name" do
+        Foo.complete_for('str').should =~ ([' string '])
+      end
+
+       it "should not complete the logical operators at the beginning" do
+        Foo.complete_for('a').should_not contain(['and'])
+      end
+
+      it "should complete the string comparators" do
+        Foo.complete_for('string ').should =~ (["string != ", "string !~ ", "string = ", "string ~ "])
+      end
+
+      it "should complete the numerical comparators" do
+        Foo.complete_for('int ').should =~ (["int != ", "int < ", "int <= ", "int = ", "int > ", "int >= "])
+      end
+
+      it "should complete the temporal (date) comparators" do
+        Foo.complete_for('date ').should =~ (["date = ", "date < ", "date > "])
+      end
+
+      it "should raise error for unindexed field" do
+        lambda { Foo.complete_for('unindexed = 10 ')}.should raise_error(ScopedSearch::QueryNotSupported)
+      end
+
+      it "should raise error for unknown field" do
+        lambda {Foo.complete_for('unknown = 10 ')}.should raise_error(ScopedSearch::QueryNotSupported)
+      end
+
+      it "should complete logical comparators" do
+        Foo.complete_for('string ~ fo ').should contain("string ~ fo and", "string ~ fo or")
+      end
+
+      it "should complete prefix operators" do
+        Foo.complete_for(' ').should contain(" has", " not")
+      end
+
+      it "should not complete logical infix operators" do
+        Foo.complete_for(' ').should_not contain(" and", " or")
+      end
+
+      it "should not repeat logical operators" do
+        Foo.complete_for('string = foo and ').should_not contain("string = foo and and", "string = foo and or")
+      end
+    end
+
+    context 'using an aliased field' do
+      it "should complete an explicit match using its alias" do
+        Foo.complete_for('al').should contain(' alias ')
+      end
+    end
+
+    context 'value auto complete' do
+      it "should complete values list of values " do
+        Foo.complete_for('explicit = ').should have(1).item
+      end
+
+      it "should complete values should contain baz" do
+        Foo.complete_for('explicit = ').should contain('explicit = baz')
+      end
+    end
+
+    context 'auto complete relations' do
+      it "should complete related object name" do
+        Foo.complete_for('ba').should contain(' bars.related ')
+      end
+
+      it "should complete related object name with field name" do
+        Foo.complete_for('bars.').should contain(' bars.related ')
+      end
+    end
+
+    context 'using null prefix operators queries' do
+
+      it "should complete has operator" do
+        Foo.complete_for('has strin').should eql(['has string '])
+      end
+
+      it "should complete null? operator" do
+        Foo.complete_for('null? st').should eql(['null? string '])
+      end
+
+      it "should complete set? operator" do
+        Foo.complete_for('set? exp').should eql(['set? explicit '])
+      end
+
+      it "should complete null? operator for explicit field" do
+        Foo.complete_for('null? explici').should eql(['null? explicit '])
+      end
+
+      it "should not complete comparators after prefix statement" do
+        Foo.complete_for('has string ').should_not contain(['has string = '])
+      end
+
+      it "should not complete infix operator" do
+        Foo.complete_for('has string ').should_not contain('has string = ')
+      end
+    end
+  end
+end

data/spec/integration/key_value_querying_spec.rb

@@ -0,0 +1,87 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+  # These specs will run on all databases that are defined in the spec/database.yml file.
+  # Comment out any databases that you do not have available for testing purposes if needed.
+  ScopedSearch::RSpec::Database.test_databases.each do |db|
+
+    describe ScopedSearch, "using a #{db} database" do
+
+      before(:all) do
+        ScopedSearch::RSpec::Database.establish_named_connection(db)
+      end
+
+      after(:all) do
+        ScopedSearch::RSpec::Database.close_connection
+      end
+
+      context 'querying a key-value schema' do
+
+        before(:all) do
+          ActiveRecord::Migration.create_table(:keys) { |t| t.string :name }
+          class ::Key < ActiveRecord::Base; has_many :facts; end
+
+          ActiveRecord::Migration.create_table(:facts) { |t| t.string :value; t.integer :key_id; t.integer :bar_id }
+          class ::Fact < ActiveRecord::Base; belongs_to :key; belongs_to :bar; end
+
+          # The class that will run the queries
+          ::Bar = ScopedSearch::RSpec::Database.create_model(:name => :string) do |klass|
+            klass.has_many :facts
+            klass.has_many :keys, :through => :facts
+            klass.scoped_search :in => :facts, :on => :value, :rename => :facts, :in_key => :keys, :on_key => :name, :complete_value => true
+          end
+
+          @key1 = Key.create!(:name => 'color')
+          @key2 = Key.create!(:name => 'size')
+
+
+          @bar1 = Bar.create!(:name => 'bar')
+          @bar2 = Bar.create!(:name => 'barbary')
+
+          Fact.create!(:value => 'green', :key => @key1, :bar => @bar1)
+          Fact.create!(:value => 'gold' , :key => @key1, :bar => @bar2)
+          Fact.create!(:value => '5'    , :key => @key2, :bar => @bar1)
+
+        end
+
+        after(:all) do
+          ScopedSearch::RSpec::Database.drop_model(Bar)
+          ScopedSearch::RSpec::Database.drop_model(Fact)
+          ScopedSearch::RSpec::Database.drop_model(Key)
+          Object.send :remove_const, :Fact
+          Object.send :remove_const, :Key
+          Object.send :remove_const, :Bar
+        end
+
+        it "should find all bars with a fact name color and fact value green" do
+          Bar.search_for('facts.color = green').should have(1).items
+        end
+
+        it "should find all bars with a fact name size and fact value 5" do
+            Bar.search_for('facts.size = 5').should have(1).items
+        end
+
+        it "should find all bars with a fact color green and fact size 5" do
+          Bar.search_for('facts.color = green and facts.size = 5').should have(1).items
+        end
+
+        it "should find all bars that has size value" do
+          Bar.search_for('has facts.size').should have(1).items
+        end
+
+        it "should find all bars that has color value" do
+          Bar.search_for('has facts.color').should have(2).items
+        end
+
+        it "should complete facts names" do
+          Bar.complete_for('facts.').should have(2).items
+        end
+
+         it "should complete values for fact name = color" do
+          Bar.complete_for('facts.color = ').should have(2).items
+        end
+
+      end
+
+    end
+  end
+