ruby_simple_search 0.0.1 → 0.0.2

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/README.md

@@ -1,16 +1,45 @@
 # RubySimpleSearch
 
-RubySimpleSearch allows to search on the table fields. 
-e.g. string and text fields.
+RubySimpleSearch allows you to search on the table fields (string and text fields)
+very easily.
 
-Sometimes we want to do search on the post's title and content
-or user's email, username and description or on other models but in same way.
-For those searches we use MySql's or Postgresql's LIKE operator to get the
-results. While doing same thing on the differet models you actually add lots of 
-duplications in your code.
+Mostly on the admin side, we do have a common text field to search the table
+column's data.
+
+Sometimes we want to do a search on the title, content and ratings on the post model or
+email, username and description on the user model. For those searches we use MySQL's
+or PostgreSQL's LIKE operator to get the results. While doing the same thing again and again
+on the different models you actually add lots of duplication in your code.
 
 To avoid duplicating the same code, use RubySimpleSearch :)
 
+#### RubySimpleSearch Features:
+- Added like pattern support ('beginning', 'ending', 'containing', 'underscore', 'plain').
+  By default pattern is 'containing'
+
+```Ruby
+    simple_search_attributes :name, :address, :pattern => :ending
+    # It will search like '%york'
+
+    simple_search_attributes :name, :address, :pattern => :begining
+    # It will search like 'york%'
+
+    simple_search_attributes :name, :address, :pattern => :containing
+    # It will search like '%york%'
+
+    simple_search_attributes :name, :address, :pattern => :underscore
+    # It will search like '_o_'
+
+    simple_search_attributes :name, :address, :pattern => :plain
+    # It will search like 'york'
+```
+- Added **block** support to simple_search method, so user can extend the query as per
+  his/her requirements (Now you can operate on the integer/decimal values also)
+
+- Added specs
+
+- Added exception handler
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -33,23 +62,46 @@ Define attributes that you want to search through RubySimpleSearch
 class Post < ActiveActiveRecord::Base
   include RubySimpleSearch
 
-  simple_search_attributes :title, :description
+  simple_search_attributes :title, :description, :pattern => :begining
 end
-
-class User < < ActiveActiveRecord::Base
+```
+```Ruby
+class User < ActiveActiveRecord::Base
   include RubySimpleSearch
 
   simple_search_attributes :email, :username, :address
 end
-
-Post.simple_serach('tutorial')
-# => posts which have 'tutorial' text in title or in description fields
-
-User.simple_search('Mechanciles')
-# => users which have 'Mechanicles' text in the email, username and in address
-
+```
+While defining simple_search_attributes, don't add integer/decimal data
+attributes to it, instead of this you can do integer/decimal operation
+by passing block to simple search method
+```Ruby
+Post.simple_search('tuto')
+# => posts which have 'tuto%' text in the title or in the description fields
+```
+```Ruby
+User.simple_search('mechanicles')
+# => users which have 'mechanicles' text in the email, username and in address
+```
+```Ruby
+User.simple_search('mechanicles') do |search_term|
+  ["and address != ?", search_term]
+end
+# => You can pass block to simple_search method so you can extend it as your
+# wish but you need to return an array of valid parameters like you do in #where
+# method
+```
+```Ruby
 Model.simple_search('string')
-# => will return ActiveRecord::Relation object
+# => with and without block will return ActiveRecord::Relation object
+```
+```Ruby
+Model.simple_search('string').to_sql
+#OR
+User.simple_search('mechanicles') do |search_term|
+  ["and address != ?", search_term]
+end.to_sql
+# => will return sql query in string format
 ```
 ## Contributing
 

data/lib/ruby_simple_search.rb

@@ -1,38 +1,6 @@
-# RubySimpleSearch allows to search on the table fields. 
-# e.g. string and text fields.
-#
-# Sometimes we want to do search on the post's title and content
-# or user's email, username and description or on other models but in same way.
-# For those searches we use MySql's or Postgresql's LIKE operator to get the
-# results. While doing same thing on the differet models you actually add lots of
-# duplications in your code.
-#
-# To avoid duplicating the same code, use RubySimpleSearch :)
-#
-# Define attributes that you want to search through RubySimpleSearch
-#
-#   class Post < ActiveActiveRecord::Base
-#     include RubySimpleSearch
-#
-#     simple_search_attributes :title, :description
-#   end
-#
-#   class User < < ActiveActiveRecord::Base
-#     include RubySimpleSearch
-#
-#     simple_search_attributes :email, :username, :address
-#   end
-#
-#  Post.simple_serach('tutorial')
-#  # => posts which have tutorial text in title or in description fields
-#
-#  User.simple_search('Mechanciles')
-#  # => users which have mechanicles text in the email, username and in address
-#
-#  Model.simple_search('string') will return ActiveRecord::Relation object
-
-
 require "ruby_simple_search/version"
+require "ruby_simple_search/like_pattern"
+require "ruby_simple_search/errors"
 require 'active_support/concern'
 
 module RubySimpleSearch
@@ -42,30 +10,78 @@ module RubySimpleSearch
     class_eval do
       def self.simple_search_attributes(*args)
         @simple_search_attributes = []
+        # default pattern is '%q%'
+        @simple_search_pattern = RubySimpleSearch::LIKE_PATTERNS[:containing]
         args.each do |arg|
-          @simple_search_attributes << arg
+          if !arg.is_a?(Hash)
+            @simple_search_attributes << arg
+          else
+           set_pattern(arg[:pattern]) if arg[:pattern].present?
+          end
         end
       end
     end
   end
 
   module ClassMethods
-    def simple_search(q)
-      raise ArgumentError, "Argument is not string" unless q.is_a? String
+    def simple_search(search_term, &block)
+      raise RubySimpleSearch::Error::ATTRIBUTES_MISSING if @simple_search_attributes.blank?
+      raise ArgumentError, "Argument is not string" unless search_term.is_a? String
+
+      sql_query = nil
+      extended_query = nil
+      sql_query_condition = ""
+      sql_query_values = []
 
-      query = ""
-      patterned_text = "%#{q.downcase}%"
+      patterned_text = "#{@simple_search_pattern.gsub('q', search_term.try(:downcase))}"
 
       @simple_search_attributes.each do |attr|
-        query += if query == ""
-                   "LOWER(#{attr.to_s}) LIKE ?" 
-                 else
-                   " OR LOWER(#{attr.to_s}) LIKE ?"
-                 end
+        sql_query_condition << set_sql_query_condition(attr, sql_query_condition)
+        sql_query_values << patterned_text
+      end
+
+      if block.is_a? Proc
+        sql_query_condition = "(#{sql_query_condition})"
+        extended_query = block.call(search_term)
+      end
+
+      if !extended_query.nil?
+        sql_query_values, sql_query_condition = extend_simple_search(extended_query,
+                                                                     sql_query_condition,
+                                                                     sql_query_values)
+      end
+      sql_query = [sql_query_condition, sql_query_values]
+
+      where(sql_query.try(:flatten))
+    end
+
+    private
+
+    def set_pattern(pattern)
+      pattern = RubySimpleSearch::LIKE_PATTERNS[pattern.to_sym] rescue nil
+      raise RubySimpleSearch::Error::INVALID_PATTERN if pattern.nil?
+      @simple_search_pattern = pattern
+    end
+
+    def extend_simple_search(extended_query, sql_query_condition, sql_query_values)
+      raise RubySimpleSearch::Error::INVALID_TYPE unless extended_query.is_a?(Array)
+      extended_query_condition = extended_query[0]
+      extended_query_values = extended_query - [extended_query[0]]
 
+      if extended_query_condition.count('?') != (extended_query_values.size)
+        raise RubySimpleSearch::Error::INVALID_CONDITION
       end
 
-      where([query] + Array.new(@simple_search_attributes.size, patterned_text))
+      sql_query_condition = [sql_query_condition, extended_query_condition].join(' ')
+      sql_query_values = sql_query_values + extended_query_values
+
+      [sql_query_values, sql_query_condition]
+    end
+
+    def set_sql_query_condition(attr, sql_query_condition)
+      return "LOWER(#{attr.to_s}) LIKE ?" if sql_query_condition.blank?
+      " OR LOWER(#{attr.to_s}) LIKE ?"
     end
+
   end
 end

data/lib/ruby_simple_search/errors.rb

@@ -0,0 +1,10 @@
+require "ruby_simple_search/errors"
+
+module RubySimpleSearch
+  module Error
+    ATTRIBUTES_MISSING     = "Simple search attributes are missing"
+    INVALID_TYPE           = "Extended query is not an array type"
+    INVALID_CONDITION      = "Extended query's array conditions are wrong"
+    INVALID_PATTERN        = "Pattern is wrong. it should be in the list #{RubySimpleSearch::LIKE_PATTERNS.keys}"
+  end
+end

data/lib/ruby_simple_search/like_pattern.rb

@@ -0,0 +1,4 @@
+module RubySimpleSearch
+  LIKE_PATTERNS = { plain: 'q', underscore: '_q_', beginning: 'q%',
+                    ending: '%q', containing: '%q%'}
+end

data/lib/ruby_simple_search/version.rb

@@ -1,3 +1,3 @@
 module RubySimpleSearch
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/ruby_simple_search.gemspec

@@ -14,6 +14,8 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency "activesupport", ">= 3.0.0"
   gem.add_dependency "activerecord",  ">= 3.0.0"
+  gem.add_dependency "sqlite3"
+  gem.add_development_dependency "rspec"
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/spec/lib/user.rb

@@ -0,0 +1,8 @@
+require 'active_record'
+require_relative "../../lib/ruby_simple_search.rb"
+
+class User < ActiveRecord::Base
+  include RubySimpleSearch
+
+  simple_search_attributes :name, :email, :contact, :address
+end

data/spec/lib/user2.rb

@@ -0,0 +1,6 @@
+require 'active_record'
+require_relative "../../lib/ruby_simple_search.rb"
+
+class User2 < ActiveRecord::Base
+  include RubySimpleSearch
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+require 'rspec'
+require 'active_record'
+
+ActiveRecord::Migration.verbose = false
+
+RSpec.configure do |config|
+  config.before(:all) do
+    ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+    create_database
+    User.create :email  => "alice@example.com",
+                :name => "alice", :address => "usa",
+                :contact => '12345', :age => 60
+    User.create :email  => "bob@example.com",
+                :name => "bob", :address => "usa",
+                :contact => "56789", :age => 26
+  end
+
+  config.after(:all) do
+    drop_database
+  end
+end
+
+def create_database
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :users do |t|
+      t.string :name
+      t.text :address
+      t.text :contact
+      t.string :email
+      t.integer :age
+      t.timestamps
+    end
+  end
+end
+
+def drop_database
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end

data/spec/user_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require_relative "../spec/lib/user.rb"
+require_relative "../spec/lib/user2.rb"
+
+describe User do
+
+  describe ".simple_search_attributes" do
+
+    it "returns an exception if simple_search_attributes is not called while loading the model" do
+      expect { User2.simple_search('usa') }.to raise_error(RubySimpleSearch::Error::ATTRIBUTES_MISSING)
+    end
+
+    it "sets simple_search_attributes" do
+      User2.simple_search_attributes :name, :contact
+      expect(User2.instance_variable_get("@simple_search_attributes")).to eq([:name, :contact])
+    end
+
+    it "has default pattern" do
+      User2.simple_search_attributes :name, :contact
+      expect(User2.instance_variable_get("@simple_search_pattern")).to eq('%q%')
+    end
+
+    it "can have patterns like plain, beginning, ending, containing and underscore" do
+      User2.simple_search_attributes :name, :contact, :pattern => :plain
+      expect(User2.instance_variable_get("@simple_search_pattern")).to eq('q')
+      User2.simple_search_attributes :name, :contact, :pattern => :beginning
+      expect(User2.instance_variable_get("@simple_search_pattern")).to eq('q%')
+      User2.simple_search_attributes :name, :contact, :pattern => :ending
+      expect(User2.instance_variable_get("@simple_search_pattern")).to eq('%q')
+      User2.simple_search_attributes :name, :contact, :pattern => :containing
+      expect(User2.instance_variable_get("@simple_search_pattern")).to eq('%q%')
+      User2.simple_search_attributes :name, :contact, :pattern => :underscore
+      expect(User2.instance_variable_get("@simple_search_pattern")).to eq('_q_')
+    end
+
+    it "should raise an exception if pattern is wrong" do
+      expect{ User2.simple_search_attributes :name, :pattern => 'wrong' }.to raise_error(RubySimpleSearch::Error::INVALID_PATTERN)
+    end
+  end
+
+  describe ".simple_search" do
+    context "Simple" do
+      it "searches users whose name are 'alice'" do
+        user = User.find_by_name('alice')
+        users = User.simple_search('alice')
+        users.should include(user)
+      end
+
+      it "returns empty records if contact number does not exist" do
+        users = User.simple_search('343434')
+        users.should be_empty
+      end
+
+      it "searches user records if user belongs to 'USA'" do
+        users = User.where(:address => 'usa')
+        searched_users = User.simple_search('usa')
+        expect(users.to_a).to eq(searched_users.to_a)
+      end
+
+      it "searches the records with beginning pattern" do
+        users = User.where("name like ?", 'bo%')
+        User.simple_search_attributes :name, :contact, :address, :pattern => :beginning
+        searched_users = User.simple_search('bo')
+        expect(users.count).to eq(searched_users.count)
+      end
+
+      it "searches the records with ending pattern" do
+        users = User.where("name like ?", '%ce')
+        User.simple_search_attributes :name, :contact, :address, :pattern => :ending
+        searched_users = User.simple_search('ce')
+        expect(users.count).to eq(searched_users.count)
+      end
+
+      it "searches the records with underscore pattern" do
+        users = User.where("name like ?", 'ce')
+        User.simple_search_attributes :name, :contact, :address, :pattern => :underscore
+        searched_users = User.simple_search('ce')
+        expect(users.count).to eq(searched_users.count)
+      end
+
+      it "searches the records with plain pattern" do
+        users = User.where("name like ?", 'bob')
+        User.simple_search_attributes :name, :contact, :address, :pattern => :plain
+        searched_users = User.simple_search('bob')
+        expect(users.count).to eq(searched_users.count)
+      end
+    end
+
+    context "Extendable" do
+      it "returns users who live in usa and their age shoule be greater than 50" do
+        User.simple_search_attributes :name, :contact, :address, :pattern => :plain
+        users = User.where(:age => 60)
+        searched_users = User.simple_search('usa') do |search_term|
+          ['AND age > ?', 50]
+        end
+        expect(users.to_a).to eq(searched_users.to_a)
+      end
+
+      it "returns exception if array condition is wrong in simple_search block" do
+        expect{ User.simple_search('usa') do |search_term|
+          ['AND age > ?', 50, 60]
+        end }.to raise_error(RubySimpleSearch::Error::INVALID_CONDITION)
+      end
+
+      it "returns exception if return value is not an array type" do
+        expect{ User.simple_search('usa') do |search_term|
+          "Wrong return"
+        end }.to raise_error(RubySimpleSearch::Error::INVALID_TYPE)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_simple_search
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-18 00:00:00.000000000 Z
+date: 2013-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -43,6 +43,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: It will search on the attributes that you provided to simple_search_attributes
   method
 email:
@@ -52,13 +84,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/ruby_simple_search.rb
+- lib/ruby_simple_search/errors.rb
+- lib/ruby_simple_search/like_pattern.rb
 - lib/ruby_simple_search/version.rb
 - ruby_simple_search.gemspec
+- spec/lib/user.rb
+- spec/lib/user2.rb
+- spec/spec_helper.rb
+- spec/user_spec.rb
 homepage: https://github.com/mechanicles/ruby_simple_search
 licenses: []
 post_install_message: 
@@ -79,8 +118,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Ruby simple search for ActiveRecord
-test_files: []
+test_files:
+- spec/lib/user.rb
+- spec/lib/user2.rb
+- spec/spec_helper.rb
+- spec/user_spec.rb