findable_by 0.1.0

data/README.markdown

@@ -0,0 +1,46 @@
+findable_by
+=
+
+findable_by is a simple Rails 3 plugin to improve a way how you search for records. You can pass the search form parameters directly to the find_with method in your relation, and the plugin will take care to build a correct query in a safer way.
+
+See below how it's works.
+
+Install:
+-
+
+In your Gemfile:
+
+    gem "findable_by"
+
+Usage
+-
+
+    class Person < ActiveRecord::Base
+      scope :gender, proc { |value| where(:gender => value) }
+  
+      findable_by :first_name,          :using => :like
+      findable_by :last_name,           :using => UpcaseFinder
+      findable_by :primary_contact_id,  :using => :equals
+      findable_by :number1_fan,         :using => proc { |attribute, value| where("1=1") }
+      findable_by :gender,              :using => proc { |attribute, value| gender(value) }
+      findable_by :age,                 :using => :between, :with => [ :min, :max ]
+      findable_by :birth_date,          :using => :between, :with => [ :min, :max ]
+    end
+    
+And now you can search:
+
+    relation = Person.scoped
+    relation = relation.find_with(params[:search])
+    relation.all
+  
+TODO
+-
+
+README and some documentation.
+
+Bugs and Feedback
+-
+
+http://github.com/thiagomoretto/findable_by/issues
+
+MIT License. Copyright 2010.

data/init.rb

@@ -0,0 +1 @@
+require "findable_by"

data/lib/findable_by/finders/between_finder.rb

@@ -0,0 +1,5 @@
+class BetweenFinder < Finder
+  def build_condition(relation, attribute, value, params)
+    relation.where([ "#{relation.table_name}.#{attribute} BETWEEN ? AND ?", value.first, value.last ])
+  end
+end

data/lib/findable_by/finders/equals_finder.rb

@@ -0,0 +1,5 @@
+class EqualsFinder < Finder
+  def build_condition(relation, attribute, value, params)
+    relation.where(attribute => value)
+  end
+end

data/lib/findable_by/finders/like_finder.rb

@@ -0,0 +1,5 @@
+class LikeFinder < Finder
+  def build_condition(relation, attribute, value, params)
+    relation.where([ "UPPER(#{relation.table_name}.#{attribute}) LIKE '%' || UPPER(?) || '%'", value ])
+  end
+end

data/lib/findable_by/finders/proc_finder.rb

@@ -0,0 +1,11 @@
+class ProcFinder < Finder
+  attr_accessor :proc
+  def initialize(options, proc)
+    super(options)
+    self.proc = proc
+  end
+  
+  def build_condition(relation, attribute, value, params)
+    relation & proc.call(attribute, value)
+  end
+end

data/lib/findable_by/version.rb

@@ -0,0 +1,3 @@
+module FindableBy
+  VERSION = "0.1.0".freeze
+end

data/lib/findable_by.rb

@@ -0,0 +1,92 @@
+module FindableBy
+  module Relation
+    def find_with(params)
+      relation = self.dup
+      params.each do |attribute, value|
+        finder = self._finders[attribute]
+
+        if not finder.blank?
+          if not finder.options[:with].blank?
+            # value is replaced in this case.
+            value = _fb_override_value(attribute, finder.options[:with], params)
+          end
+          
+          if _fb_is_value_ok(value) 
+            relation = finder.send(:build_condition, relation, attribute, value, params) 
+          end
+        end
+      end if not params.blank?
+      
+      relation
+    end
+  
+  private
+    def _fb_is_value_ok(value)
+      not value.blank? or (value.is_a?(Hash) and value.all?)
+    end
+  
+    def _fb_override_value(attribute, with_opts, params)
+      case with_opts
+      when Symbol
+        raise NotImplementedError
+      when Array
+        value = with_opts.collect{ |wp| params[attribute][wp] }
+      end
+      value
+    end
+  end
+  
+  module ActsAsFindable
+    extend ActiveSupport::Concern
+    
+    included do 
+      class_attribute :_finders
+      self._finders = HashWithIndifferentAccess.new{ |h,k| h[k] = [] }
+    end
+        
+    private
+      module ClassMethods
+        def findable_by(*attr_names)
+          options = attr_names.extract_options!
+          options.merge!(:attributes => attr_names.flatten)
+          options[:using] = :equals if not options.key?(:using)
+          options[:attributes].each do |attribute|
+            using_what = options[:using]
+            
+            if using_what.is_a?(Class)
+              self._finders[attribute] = using_what.new(options)
+            elsif using_what.is_a?(Proc)
+              self._finders[attribute] = ProcFinder.new(options, using_what)
+            else
+              self._finders[attribute] = Kernel.const_get("#{options[:using]}_finder".classify).new(options)
+            end
+          end
+        end
+        
+        def inherited(base)
+          dup = _finders.dup
+          base._finders = dup.each{ |k,v| dup[k] = v.dup }
+          super
+        end
+      end
+  end
+end
+
+class Finder
+  attr_accessor :options
+  def initialize(options)
+    self.options = options
+  end
+  
+  def build_condition(relation, attribute, value, params)
+    raise NotImplementedError
+  end
+end
+
+Dir[File.dirname(__FILE__) + "/findable_by/finders/*.rb"].sort.each do |path|
+  filename = File.basename(path)
+  require "findable_by/finders/#{filename}"
+end
+
+ActiveRecord::Base.send(:include, FindableBy::ActsAsFindable)
+ActiveRecord::Relation.send(:include, FindableBy::Relation)

data/test/connection/native_sqlite3/in_memory_connection.rb

@@ -0,0 +1,9 @@
+print "Using native SQLite3\n"
+require 'logger'
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+class SqliteError < StandardError
+end
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database  => ':memory:')
+load("schema/schema.rb")

data/test/findable_by_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+require 'support/models'
+
+class FindableByTest < ActiveRecord::TestCase
+
+  test "should generate a SQL to find a person by first name using like" do
+    with_scoped(Person) do |person|
+      assert_not_nil person.find_with(:first_name => "OMG!").to_sql
+    end
+  end
+  
+  test "should generate a SQL to find a person using a proc" do
+    with_scoped(Person) do |person|
+      assert_not_nil person.find_with(:number1_fan => "Don't care").to_sql
+    end
+  end
+
+  test "should generate a SQL to find a person using a proc calling a scope" do
+    with_scoped(Person) do |person|
+      sql = person.find_with("first_name" => "OMG!", :gender => 'M').to_sql
+      assert_not_nil sql =~ /first_name/ and sql =~ /gender/
+    end
+  end
+  
+  test "should generate a SQL to find a person calling 'find_with' chained" do
+    with_scoped(Person) do |person|
+      assert_not_nil person.find_with(:first_name => "OMG!").find_with(:gender => 'F').to_sql
+    end
+  end
+  
+  test "should generate a SQL to find a person by primary_contact_id using equals" do
+    with_scoped(Person) do |person|
+      assert_not_nil person.find_with(:primary_contact_id => 1).to_sql
+    end
+  end
+  
+  test "should generate a SQL to find a person using a custom finder" do
+    with_scoped(Person) do |person|
+      assert person.find_with(:last_name => "omg").to_sql =~ /OMG/
+    end
+  end
+  
+  test "should generate a SQL to find people by age range" do
+    with_scoped(Person) do |person|
+      assert person.find_with(:age => { :min => 20, :max => 45 }).to_sql =~ /BETWEEN 20 AND 45/
+    end
+  end
+
+  test "should generate a SQL to find people by birth date range" do
+    with_scoped(Person) do |person|
+      params, params[:birth_date] = {}, {}
+      params[:birth_date][:min], params[:birth_date][:max] = Time.now - 1.day, Time.now + 1.day
+      assert person.find_with(params).to_sql =~ /BETWEEN/
+    end
+  end
+private
+  def with_scoped(model, &block)
+    block.call(model.send(:scoped))
+  end
+  
+end

data/test/schema/schema.rb

@@ -0,0 +1,13 @@
+ActiveRecord::Schema.define do
+  
+  create_table :people, :force => true do |t|
+    t.string     :first_name, :null => false
+    t.string     :last_name
+    t.references :primary_contact
+    t.string     :gender, :limit => 1
+    t.references :number1_fan
+    t.integer    :age, :limit => 3
+    t.integer    :lock_version, :null => false, :default => 0
+  end  
+  
+end

data/test/support/models.rb

@@ -0,0 +1,20 @@
+class UpcaseFinder < Finder
+  def build_condition(relation, attribute, value, params)
+    relation.where(attribute => value.upcase!)
+  end
+end
+
+class Person < ActiveRecord::Base
+  scope :gender, proc { |value| where(:gender => 'F') }
+  
+  findable_by :first_name,          :using => :like
+  findable_by :last_name,           :using => UpcaseFinder
+  findable_by :primary_contact_id,  :using => :equals
+  findable_by :number1_fan,         :using => proc { |attribute, value| where("1=1") }
+  findable_by :gender,              :using => proc { |attribute, value| gender(value) }
+  findable_by :age,                 :using => :between, :with => [ :min, :max ]
+  findable_by :birth_date,          :using => :between, :with => [ :min, :max ]
+  
+  # TODO: findable_by :gender,              :through => :gender     # uses scope :gender
+  # TODO: findable_by :gender                                       # uses (:using => :equals)
+end

data/test/test_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup
+
+require 'test/unit'
+require 'mocha'
+
+require 'active_model'
+require 'active_record'
+require 'action_controller'
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+require 'findable_by'
+require 'connection/native_sqlite3/in_memory_connection'
+

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: findable_by
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Thiago Moretto
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-12 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: Even easier to find records!
+email: thiago@moretto.eng.br
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- init.rb
+- lib/findable_by.rb
+- lib/findable_by/finders/between_finder.rb
+- lib/findable_by/finders/equals_finder.rb
+- lib/findable_by/finders/like_finder.rb
+- lib/findable_by/finders/proc_finder.rb
+- lib/findable_by/version.rb
+- README.markdown
+- test/connection/native_sqlite3/in_memory_connection.rb
+- test/findable_by_test.rb
+- test/schema/schema.rb
+- test/support/models.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/thiagomoretto/findable_by
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Improving a way how you find records!
+test_files: 
+- test/connection/native_sqlite3/in_memory_connection.rb
+- test/findable_by_test.rb
+- test/schema/schema.rb
+- test/support/models.rb
+- test/test_helper.rb