yep_searchable 0.0.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,163 @@
+#YepSearchable
+==============
+
+This is a ruby gem to search in Ruby models as ActiveRecord::Base and ActiveResources::Base.
+
+<b>Beta notes:</b> The search is temporarily working as "contains" clauses.
+
+
+##Installing
+
+In your Gemfile, add the following line of code:
+<pre>gem 'yep_searchable'</pre>
+
+
+##Configuring
+
+### ActiveRecord Search
+In your ActiveRecord model, add this line of code:
+<pre>searchable_resource searchable_columns: [:name, :notes]</pre>
+
+For example:
+```ruby
+class Brand < ActiveRecord::Base
+
+    searchable_resource searchable_columns: [:name]
+    ....
+
+end
+```
+
+```ruby
+class Car < ActiveRecord::Base
+
+  searchable_resource searchable_columns: [:model, :color]
+    
+  belongs_to :brand
+  ....
+
+end
+```
+
+### ActiveResource Search
+Your ActiveResource must implement YepSearchable::YepResource, like this:
+
+```ruby
+class Brand < YepSearchable::YepResource
+  self.site = "http://127.0.0.1"
+  ...
+end
+```
+
+In YepResource you have two new attributes:
+```ruby
+  ...
+  self.search_path = "search_resource" # this is the default value
+  self.search_ids_path = "search_ids" # this is the default value
+  ...
+```
+
+For each of this path you <b>must create an route and an action on source controller</b>.
+Example:
+
+
+```ruby
+class BrandController < ApplicationController
+  ...
+  # GET /brands/search_resource
+  def search_resource
+    @brands = Brand.search(params[:query])
+    
+    render json: @brands
+  end
+  
+  # GET /brands/search_ids
+  def search_ids
+    ids = Brand.search_only_ids(params[:query])
+    
+    render json: ids
+  end
+  ...
+end
+```
+
+### Declaring relations between ActiveRecord and YepResource
+Once you search for "Ferrari" you are expect to receive the cars branded by Ferrari.
+So in your ActiveRecord "searchable_resource" declaration, you should add the following option:
+```ruby
+searchable_resource searchable_columns: [:name, :notes], yep_resources: [{class_name: :brand, foreign_key: :brand_id}]
+```
+
+In this case, if you search like this:
+```ruby
+Car.search("ferrari")
+```
+
+The result will be all cars that contain "Ferrari" in the <b>model</b>, <b>color</b> or the <b>brand_id</b> equal for the brands that contains "ferrari" in the name.
+Comparing to an SQL command, is something like:
+```sql
+SELECT * FROM cars WHERE cars.model LIKE '%FERRARI%' OR cars.color LIKE '%FERRARI%' 
+--here is the trick
+OR (cars.brand_id IN (SELECT id FROM brands WHERE brands.name LIKE '%FERRARI%'));
+```
+
+##Usage
+The yep_searchable gem provide differents way for search.
+You can give more than one parameter or not propagate the search.
+The examples will describe the gem methods.
+
+### Searching
+- You can search with more than one parameter:
+
+```ruby
+Car.search("ferrari", "red")
+# this will look for all cars that contain "ferrari" or "red" in the name, color or brand name
+```
+
+- You are able to not propagate the search, the search will not look for the relations:
+
+```ruby
+Car.search(false, "red")
+# this will look for all cars that contain "red" in the name or color BUT WILL NOT SEARCH FOR BRANDS THAT CONTAINS "RED" IN THE NAME
+```
+
+### Searching only IDS
+- You can search only the model ids using the method "search_only_ids":
+
+```ruby
+Car.search_only_ids("ferrari", "red")
+# this will look for all cars ids that contain "ferrari" or "red" in the name, color or brand name
+```
+
+- As the normal search, you can propagate the search or not:
+
+```ruby
+Car.search_only_ids(false, "red")
+# this will look for all cars ids that contain "red" in the name or color BUT WILL NOT SEARCH FOR BRANDS THAT CONTAINS "RED" IN THE NAME
+```
+
+### Pagination
+- You can paginate your search using the method "search_by_page", the search by page method have the following parameters:
+- <i><b>only_ids</b> - default false</i>
+- <i><b>page_number</b> - default nil</i>
+- <i><b>number_of_rows</b> - default nil - number of rows per page</i>
+- <i><b>propagate</b> - default true</i>
+
+Example:
+
+```ruby
+Car.search_by_page(false, 1, 30, true, "ferrari", "red")
+# this will look for the first page, 30 cars 
+# that contain "ferrari" or "red" in the name, color or brand name
+```
+
+### Is searchable resource?
+- The YepSearchable gem provides the capability to check if a Model is searchable by the method "is_searchable_resource?"
+Example:
+
+```ruby
+Car.is_searchable_resource?
+# => true
+Motorcycle.is_searchable_resource?
+# => false
+```

data/Rakefile

@@ -0,0 +1 @@
+#!/usr/bin/env rake

data/lib/yep_searchable/configuration.rb

@@ -0,0 +1,25 @@
+module YepSearchable
+  class Configuration
+    attr_accessor :configs
+    
+    def initialize
+      @@configs ||= Hash.new
+    end
+    
+    def include_option(class_name, option_name, value)
+      @@configs ||= Hash.new
+      @@configs[class_name] ||= Hash.new
+      @@configs[class_name][option_name] = value
+    end
+    
+    def retrieve_option(class_name, option_name)
+      @@configs ||= Hash.new
+      
+      if @@configs and @@configs[class_name] 
+        @@configs[class_name][option_name]
+      else
+        nil            
+      end
+    end
+  end
+end

data/lib/yep_searchable/searchable_error.rb

@@ -0,0 +1,5 @@
+module YepSearchable
+  class SearchableError < StandardError
+    
+  end
+end

data/lib/yep_searchable/searchable_resource.rb

@@ -0,0 +1,259 @@
+require 'yep_searchable/searchable_error'
+
+module YepSearchable
+  module SearchableResource
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      def searchable_resource(options = {})
+        if not options[:searchable_columns]
+          raise SearchableError, "Searchable columns must be initialized on searchable_resource declaration"
+        end
+        
+        attr_accessor :searchable_columns
+        YepSearchable.configuration.include_option(self.to_s, "searchable_columns", options[:searchable_columns])
+        
+        if options[:yep_resources]
+          options[:yep_resources].each do |resource|
+            if resource[:class_name].nil? or resource[:foreign_key].nil?
+              raise SearchableError, "class_name and foreign_key must be declared"
+            end
+            
+            if !resource[:class_name].to_s.camelize.constantize.superclass.to_s.eql?"YepSearchable::YepResource"
+              raise SearchableError, "Only classes that implement YepResource are allowed"
+            end
+          end
+          YepSearchable.configuration.include_option(self.to_s, "yep_resources", options[:yep_resources])
+        end 
+      end
+      
+      def is_searchable_resource?
+        if YepSearchable.configuration.nil?
+          return false
+        end
+        searchable_columns = YepSearchable.configuration.retrieve_option(self.to_s, 'searchable_columns')
+        if searchable_columns.nil? or searchable_columns.empty?
+          return false
+        else
+          return true
+        end 
+      end
+      
+      def search(propagate, *query_params)
+        if !propagate.to_s.eql?"true" and !propagate.to_s.eql?"false"
+          if query_params.nil? or query_params.empty?
+            query_params = []  
+          end
+          
+          while query_params.first.instance_of?(Array)
+            query_params = query_params.first
+          end
+          query_params << propagate
+          
+          propagate = false
+        end
+        
+        return search_by_page(false, nil, nil, propagate, query_params)
+      end
+      
+      def search_only_ids(propagate, *query_params)
+        if !propagate.to_s.eql?"true" and !propagate.to_s.eql?"false"
+          if query_params.nil? or query_params.empty?
+            query_params = []  
+          end
+          
+          while query_params.first.instance_of?(Array)
+            query_params = query_params.first
+          end
+          query_params << propagate
+          
+          propagate = false
+        end
+        
+        return search_by_page(true, nil, nil, propagate, query_params)
+      end
+      
+      def search_by_page(only_ids = false, page = nil, number_of_rows = nil, propagate = true, *query_param)
+        while query_param.first.instance_of?(Array)
+          query_param = query_param.first
+        end
+        
+        if query_param.size == 1 and query_param.first.include?("$$$")
+          query_param = query_param.first.split("$$$")
+        end
+        
+        if query_param.nil? or query_param.empty?
+          raise SearchableError, "Arguments not declared in search method"
+        end
+        
+        if page
+          is_valid = Integer(page.to_s) rescue false
+          if !is_valid and is_valid <= 0
+            raise SearchableError, "Argument page must be a valid number"
+          end
+        end
+        
+        if number_of_rows
+          is_valid = Integer(number_of_rows.to_s) rescue false
+          if !is_valid and is_valid <= 0
+            raise SearchableError, "Argument number_of_rows must be a valid number"
+          end
+        end
+        
+        # query_param = arguments.split("$$$")
+        query_string = nil
+        
+        searchable_columns = YepSearchable.configuration.retrieve_option(self.to_s, 'searchable_columns')
+        if not searchable_columns
+          raise SearchableError, "Model must have searchable_resource declaration"
+        end
+        
+        query_param.each do |arg|
+          if query_string.nil?
+            query_string = "("
+          else
+            query_string = "#{query_string} OR ("
+          end
+          
+          searchable_columns.each do |column|
+            if query_string.last == "("
+              query_string = "#{query_string} #{column.to_s} LIKE '%#{arg}%'"
+            else
+              query_string = "#{query_string} OR #{column.to_s} LIKE '%#{arg}%'"
+            end
+          end
+          query_string = "#{query_string})"
+        end
+        
+        if propagate
+          relation_query_string = get_where_relations(query_param)
+          
+          if !relation_query_string.nil? and !relation_query_string.empty?
+            if !query_string.nil? and !query_string.empty?
+              query_string = "#{query_string} OR #{relation_query_string})"
+            else
+              query_string = "#{relation_query_string}"
+            end
+          end
+          
+          relation_query_string = get_where_yep_resources(query_param)
+          
+          if !relation_query_string.nil? and !relation_query_string.empty?
+            if !query_string.nil? and !query_string.empty?
+              query_string = "#{query_string} OR #{relation_query_string})"
+            else
+              query_string = "#{relation_query_string}"
+            end
+          end
+        end
+        
+        if only_ids
+          entity = []
+          
+          if page.nil? or number_of_rows.nil?
+            entity = self.select(:id).where(query_string)
+          else
+            entity = self.select(:id).paginate(page: page, per_page: number_of_rows).where(query_string)
+          end
+          
+          return_value = []
+          
+          entity.each do |ent|
+            return_value << ent.id
+          end
+          
+          return return_value
+        else
+          return_value = []
+          if page.nil? or number_of_rows.nil?
+            return_value = self.where(query_string)
+          else            
+            return_value = self.paginate(page: page, per_page: number_of_rows).where(query_string)
+          end
+          return return_value
+        end
+        
+      end
+      
+      private
+        def get_where_relations(query_array)
+          while query_array.first.instance_of?(Array)  
+            query_array = query_array.first
+          end
+          
+          query_string = ""
+          
+          reflec_keys = self.reflections.keys
+          
+          reflec_keys.each do |reflection_key|
+            reflection = self.reflections[reflection_key]  
+            
+            if reflection.macro.to_s.eql?("belongs_to") and reflection.class_name.constantize.is_searchable_resource?
+              ids = reflection.class_name.constantize.search_only_ids(query_array)
+              
+              if ids.nil? or ids.empty?
+                next
+              end
+                          
+              if query_string.empty?
+                query_string = "(#{reflection.foreign_key} IN ("
+              else
+                query_string = "#{query_string} OR (#{reflection.foreign_key} IN ("
+              end
+              
+              ids.each do |entity_id|
+                query_string = "#{query_string} #{entity_id},"
+              end
+              
+              query_string = query_string[0, query_string.size - 1]
+              query_string = "#{query_string})" 
+            end
+          end
+          
+          return query_string
+          
+        end
+      
+        def get_where_yep_resources(query_array)
+          while query_array.first.instance_of?(Array)  
+            query_array = query_array.first
+          end
+          yep_res = YepSearchable.configuration.retrieve_option(self.to_s, 'yep_resources')
+          
+          if yep_res.nil? or yep_res.empty?
+            return nil
+          end
+
+          query_string = ""
+          
+          yep_res.each do |resource|
+            if !resource[:class_name].to_s.camelize.constantize.superclass.to_s.eql?"YepSearchable::YepResource"
+              raise SearchableError, "Only classes that implement YepResource are allowed"
+            end
+            
+            ids = resource[:class_name].to_s.camelize.constantize.search_only_ids(query_array)
+              
+            if ids.nil? or ids.empty?
+              next
+            end
+                        
+            if query_string.empty?
+              query_string = "(#{resource[:foreign_key]} IN ("
+            else
+              query_string = "#{query_string} OR (#{resource[:foreign_key]} IN ("
+            end
+            
+            ids.each do |entity_id|
+              query_string = "#{query_string} #{entity_id},"
+            end
+            
+            query_string = query_string[0, query_string.size - 1]
+            query_string = "#{query_string})" 
+            
+          end
+          
+          return query_string
+        end
+    end
+  end
+end

data/lib/yep_searchable/version.rb

@@ -0,0 +1,3 @@
+module YepSearchable
+  VERSION = "0.0.2"
+end

data/lib/yep_searchable/yep_resource.rb

@@ -0,0 +1,104 @@
+require 'net/http'
+require 'uri'
+require 'active_resource'
+
+module YepSearchable
+  class YepResource < ActiveResource::Base
+    
+    class << self
+      attr_accessor :search_path, :search_ids_path
+    end
+    
+    self.search_path = nil
+    self.search_ids_path = nil
+    
+    def self.search_only_ids(*arguments)
+      if arguments.nil? or arguments.size == 0
+        return nil
+      end
+      
+      while arguments.first.instance_of?(Array)  
+        arguments = arguments.first
+      end
+      
+      query_params = nil
+      
+      arguments.each do |arg|
+        if query_params.nil?
+          query_params = "#{arg}"
+        else
+          query_params = "#{query_params}$$$#{arg}"
+        end
+      end
+      
+      begin
+        search_route = "search_ids"
+        if not self.search_ids_path.nil?
+          search_route =  self.search_ids_path
+        end   
+        
+        search_uri = "#{self.site}#{self.element_path(search_route)}?query=#{query_params}"
+        search_uri = search_uri.gsub("//", "/")
+        search_uri = search_uri.gsub("http:/", "http://")
+        search_uri = search_uri.gsub("https:/", "https://")
+        
+        search_result = Net::HTTP.get(URI.parse(search_uri))
+        
+        result = JSON.parse(search_result)
+        return result
+      rescue => error
+        puts "\nError - #{error.message}\n"
+        return nil
+      ensure
+        # finally
+      end
+      
+      return nil
+    end
+    
+    
+    def self.search(*arguments)
+      if arguments.nil? or arguments.size == 0
+        return nil
+      end
+      
+      while arguments.first.instance_of?(Array)  
+        arguments = arguments.first
+      end
+      
+      query_params = nil
+      
+      arguments.each do |arg|
+        if query_params.nil?
+          query_params = "#{arg}"
+        else
+          query_params = "#{query_params}$$$#{arg}"
+        end
+      end
+      
+      begin
+        search_route = "search_resource"
+        if not self.search_path.nil?
+          search_route =  self.search_path
+        end   
+        
+        search_uri = "#{self.site}#{self.element_path(search_route)}?query=#{query_params}"
+        search_uri = search_uri.gsub("//", "/")
+        search_uri = search_uri.gsub("http:/", "http://")
+        search_uri = search_uri.gsub("https:/", "https://")
+        
+        search_result = Net::HTTP.get(URI.parse(search_uri))
+        
+        result = JSON.parse(search_result)
+        return result
+      rescue => error
+        puts "\nError - #{error.message}\n"
+        return nil
+      ensure
+        # finally
+      end
+      
+      return nil
+    end
+  end
+end

data/lib/yep_searchable.rb

@@ -0,0 +1,32 @@
+require 'yep_searchable/configuration'
+require 'yep_searchable/yep_resource'
+require 'yep_searchable/searchable_resource'
+
+module YepSearchable
+  @@configuration = Configuration.new
+  
+  def self.configuration
+    @@configuration ||= Configuration.new
+    @@configuration
+  end
+  
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+  
+  def self.included(mod)
+    mod.extend(ClassMethods)
+  end
+  
+  class << self
+    attr_accessor :searchable_class
+  end
+end
+
+# reopen ActiveRecord and include all the above to make
+# them available to all our models if they want it
+
+ActiveRecord::Base.class_eval do
+  include YepSearchable::SearchableResource
+end

data/test/performance/browsing_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+require 'rails/performance_test_help'
+
+class BrowsingTest < ActionDispatch::PerformanceTest
+  # Refer to the documentation for all available options
+  # self.profile_options = { :runs => 5, :metrics => [:wall_time, :memory]
+  #                          :output => 'tmp/performance', :formats => [:flat] }
+
+  def test_homepage
+    get '/'
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: yep_searchable
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Luiz Santana
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+description: Lib for search using ActiveRecord and ActiveResource
+email:
+- luiz.santana@yepdev.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/yep_searchable/configuration.rb
+- lib/yep_searchable/searchable_error.rb
+- lib/yep_searchable/searchable_resource.rb
+- lib/yep_searchable/version.rb
+- lib/yep_searchable/yep_resource.rb
+- lib/yep_searchable.rb
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+- test/performance/browsing_test.rb
+- test/test_helper.rb
+homepage: http://yepdev.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: YepSearchable-0.0.2
+test_files:
+- test/performance/browsing_test.rb
+- test/test_helper.rb