has_searcher 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in has_searcher.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/has_searcher.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "has_searcher/version"
+
+Gem::Specification.new do |s|
+  s.name        = "has_searcher"
+  s.version     = HasSearcher::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Dmitry Lihachev"]
+  s.email       = ["lda@openteam.ru"]
+  s.homepage    = "http://github.com/openteam/has_searcher"
+  s.summary     = %q{Adds ability to construct search objects for indexed models}
+  s.description = %q{This gem adds ability to construct search objects for indexed models.
+                     It works with sunspot, inherited_resources and formtastic}
+
+  s.rubyforge_project = "has_searcher"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/app/controllers/crud_controller.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+class SearchController < ApplicationController
+  inherit_resources
+
+  helper_method :search_object_for
+
+  protected
+
+    def collection
+      get_collection_ivar || set_collection_ivar(search_and_paginate_collection)
+    end
+
+    def search_and_paginate_collection
+      if params[:utf8]
+        search_object = search_object_for(resource_instance_name)
+        search_object.pagination = paginate_options
+        search_object.results
+      else
+        end_of_association_chain.paginate(paginate_options)
+      end
+    end
+
+    def paginate_options(options={})
+      {
+        :page       => params[:page],
+        :per_page   => per_page
+      }.merge(options)
+    end
+
+    def per_page
+      20
+    end
+
+    def render_new_button?
+      respond_to? :new
+    end
+
+    def searcher_name(name)
+      "#{name}_search"
+    end
+
+    def create_searcher(searcher_name)
+      begin
+        searcher_clazz = searcher_name.classify.constantize
+        searcher_clazz.new(params[searcher_name]) do | searcher |
+          searcher_clazz.column_names.each do | column_name |
+            searcher[column_name] ||= params[column_name]
+          end
+        end
+      rescue NameError
+      end
+    end
+
+end
+

data/lib/app/controllers/suggestions_controller.rb

@@ -0,0 +1,21 @@
+class SuggestionsController < CrudController
+
+  def index
+    render :text => suggestions.to_json
+  end
+
+
+  protected
+
+    def suggestions
+      collection.map do | suggest |
+        { :id => suggest.id, :value => suggest.term }
+      end
+    end
+
+    def resource_instance_name
+      @resource_instance_name ||= params.delete(:model)
+    end
+
+
+end

data/lib/app/models/search.rb

@@ -0,0 +1,68 @@
+class Search < ActiveRecord::Base
+
+  attr_accessor :pagination
+
+  class << self
+    def columns
+      @columns ||= [];
+    end
+
+    def column(name, sql_type = nil, default = nil, null = true)
+      columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default,
+        sql_type.to_s, null)
+    end
+  end
+
+  delegate :results, :to => :search
+
+  def result_ids
+    search.hits.map(&:primary_key)
+  end
+
+  protected
+
+    def search
+      klass.search do | search |
+        search.keywords normalize_text(keywords) if search_columns.delete("keywords")
+        search_columns.each do | column |
+          if column_for_attribute(column).type == :text
+            search.keywords normalize(column), :fields => column
+          else
+            search.with column, normalize(column)
+          end
+        end
+        search.paginate pagination if pagination.try(:any?)
+      end
+    end
+
+    def save(validate = true)
+      validate ? valid? : true
+    end
+
+    def search_columns
+      @search_columns ||= self.class.column_names.select{ |column| normalize(column).present? }
+    end
+
+    def normalize(column)
+      if respond_to? "normalize_#{column}"
+        send "normalize_#{column}"
+      elsif self.class.serialized_attributes[column] == Array
+        [*self.send("#{column}_before_type_cast")].select(&:present?)
+      elsif column_for_attribute(column).type == :integer
+        self[column].try(:zero?) ? nil : self[column]
+      elsif column_for_attribute(column).type == :text && column == "term"
+        normalize_text(self[column])
+      else
+        self[column]
+      end
+    end
+
+    def normalize_text(text)
+      text.gsub /-/, ' ' if text
+    end
+
+    def klass
+      self.class.model_name.classify.gsub(/Search$/, '').constantize
+    end
+
+end

data/lib/has_searcher/base.rb

@@ -0,0 +1,10 @@
+class HasSearcher::Base < ::ApplicationController
+  def self.has_searcher(base)
+    base.class_eval do
+      include HasSearcher::Helpers
+      helper_method :searcher
+    end
+
+  end
+  has_searcher(self)
+end

data/lib/has_searcher/formtastic.rb

@@ -0,0 +1,62 @@
+require 'formtastic'
+
+module Formtastic
+  module SemanticFormHelper
+    def semantic_search_form_for(name, *args, &proc)
+      options = args.extract_options!
+      options.reverse_merge! :html => {:method => :get}
+      url = params[:controller].sub(/\/\w+$/, '').split("/").map(&:underscore)
+      options[:url] ||= url.push name.to_s.pluralize
+      semantic_form_for search_object_for(name), *(args << options), &proc
+    end
+  end
+
+  class SemanticFormBuilder
+    def search_button(options={})
+      commit_button I18n.t('search'), options.merge(button_html:  {name: nil},
+                                                    wrapper_html: {class: 'button'})
+    end
+
+    def default_input_type_with_text_as_string_on_search(method, options={})
+      if object.is_a?(Search) && object.column_for_attribute(method).try(:type) == :text
+        :string
+      else
+        default_input_type_without_text_as_string_on_search(method, options)
+      end
+    end
+
+    alias_method_chain :default_input_type, :text_as_string_on_search
+
+    def inputs_with_search(*args, &block)
+      if args.empty? && object.is_a?(Search)
+        args = object.class.column_names.collect do | column |
+          if belongs_to? column
+            column = column.gsub /_id$/, ''
+          end
+          column
+        end.map(&:to_sym)
+        args -= [:term]
+      end
+      inputs_without_search(*args, &block)
+    end
+
+    alias_method_chain :inputs, :search
+
+    def buttons_with_search(*args, &block)
+      args = :search if args.empty? && object.is_a?(Search)
+      buttons_without_search(*args, &block)
+    end
+
+    alias_method_chain :buttons, :search
+
+    protected
+
+      def belongs_to?(method)
+        method = method.to_s
+        method =~ /_id$/ &&
+          (reflect = object.class.reflect_on_association(method.gsub(/_id$/, '').to_sym)) &&
+          reflect.macro == :belongs_to
+      end
+  end
+end
+

data/lib/has_searcher/helpers.rb

@@ -0,0 +1,28 @@
+module HasSearcher::Helpers
+
+  protected
+
+    def searcher_for(name)
+      instance_variable_get("@#{searcher_name(name)}") ||
+          instance_variable_set("@#{searcher_name(name)}", create_searcher(searcher_name(name)))
+    end
+
+  private
+
+    def searcher_name(name)
+      "#{name}_search"
+    end
+
+    def create_searcher(searcher_name)
+      begin
+        searcher_clazz = searcher_name.classify.constantize
+        searcher_clazz.new(params[searcher_name]) do | searcher |
+          searcher_clazz.column_names.each do | column_name |
+            searcher[column_name] ||= params[column_name]
+          end
+        end
+      rescue NameError
+      end
+    end
+
+end

data/lib/has_searcher/version.rb

@@ -0,0 +1,3 @@
+module HasSearcher
+  VERSION = "0.0.1"
+end

data/lib/has_searcher.rb

@@ -0,0 +1,11 @@
+module HasSearcher
+
+end
+
+class ActionController::Base
+  def self.has_searcher
+    HasSearcher::Base.has_searcher(self)
+  end
+end
+
+require 'has_searcher/formtastic' rescue nil

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: has_searcher
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Dmitry Lihachev
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-14 00:00:00 +07:00
+default_executable: 
+dependencies: []
+
+description: |-
+  This gem adds ability to construct search objects for indexed models.
+                       It works with sunspot, inherited_resources and formtastic
+email: 
+- lda@openteam.ru
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- has_searcher.gemspec
+- lib/app/controllers/crud_controller.rb
+- lib/app/controllers/suggestions_controller.rb
+- lib/app/models/search.rb
+- lib/has_searcher.rb
+- lib/has_searcher/base.rb
+- lib/has_searcher/formtastic.rb
+- lib/has_searcher/helpers.rb
+- lib/has_searcher/version.rb
+has_rdoc: true
+homepage: http://github.com/openteam/has_searcher
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: has_searcher
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Adds ability to construct search objects for indexed models
+test_files: []
+