search_me 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4dda6eb047e473b4ddb6589405b67e8053f35f6b
+  data.tar.gz: 6f8b867f9554d4fdd6c8d84c86543196ebb617fa
+SHA512:
+  metadata.gz: 4f2223995371daf6b83e0aaee00ac97501cc877c473552fdb3debb9e2c004989a5b5cd51cb12336dd09b8eb13e179998b8d7bf784c70dc1c6c6d7734bd99953f
+  data.tar.gz: 88d8b938bca88d7c96d959f2c364f5aa64b181064aac55f73803522b4b5d5bca456f5c0f18c9d9d1643d27aefdb65e93cb2d14563deae3148094f2cf3e4409f5

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 John Hager
+
+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/lib/search_me/filters.rb

@@ -0,0 +1,100 @@
+module SearchMe
+  module Filters
+    def filter_month_quarter_or_year(month=nil, quarter=nil, year=nil)
+      month, quarter, year = sanitize_params(month, quarter, year)
+      if month
+        filter_month(month, year)
+      elsif quarter
+        filter_quarter(quarter, year)
+      else
+        filter_year(year)
+      end
+    end
+
+    def filter_year(year = nil)
+      year = sanitize_params(year).first
+
+      year ||= Date.today.year
+      date   = Date.new(year, 1, 1)
+
+      build_between_query_for(year_for_date(date))
+    end
+
+    def filter_month(month = nil, year = nil)
+      month, year = sanitize_params(month, year)
+
+      month ||= Date.today.month
+      year  ||= Date.today.year
+      date    = Date.new(year, month, 1)
+
+      build_between_query_for(month_for_date(date))
+    end
+
+    def filter_quarter(quarter = nil, year = nil)
+      quarter, year = sanitize_params(quarter, year)
+      quarter ||= (Date.today.month - 1) / 3 + 1
+      return self if quarter > 4
+
+      year    ||= Date.today.year
+      month     = (quarter - 1) * 3 + 1
+      date      = Date.new(year, month, 1)
+      
+      build_between_query_for(quarter_for_date(date))
+    end
+
+    def filter_named_duration(duration)
+      today = Date.today
+
+      duration = case duration
+      when "current_month"
+        month_for_date(today)
+      when "last_month"
+        month_for_date(1.month.ago)
+      when "f_last_month"
+        month_for_date(2.month.ago)
+      when "last_quarter"
+        quarter_for_date(today.beginning_of_quarter - 1)
+      when "current_year"
+        year_for_date(today)
+      when "last_year"
+        year_for_date(1.year.ago)
+      when "f_last_year"
+        year_for_date(2.year.ago)
+      else
+        nil # do nothing
+      end
+      if duration
+        build_between_query_for(duration)
+      else
+        self.all
+      end
+    end
+
+    private
+    def build_between_query_for(duration)
+      field = SearchMe.config.time_field
+      in_created_at = "(#{field} > ?  AND  #{field} < ?)"
+      on_created_at = "(#{field} = ?) OR  (#{field} = ?)"
+      self.where( 
+        "#{in_created_at} OR #{on_created_at}", *duration, *duration
+      )
+    end
+
+    def month_for_date(date)
+      [date.beginning_of_month, date.end_of_month]
+    end
+
+    def year_for_date(date)
+      [date.beginning_of_year, date.end_of_year]
+    end
+
+    def quarter_for_date(date)
+      [date.beginning_of_quarter, date.end_of_quarter]
+    end
+
+    def sanitize_params(*params)
+      # i.e. Integer or nil. Also no zero year, month, day
+      params.map { |p| p.to_i if p.present? && !p.to_i.zero? }
+    end
+  end
+end

data/lib/search_me/search.rb

@@ -0,0 +1,272 @@
+module SearchMe
+  module Search
+    def search_attributes 
+      @search_attributes ||= default_hash
+    end
+
+    def advanced_search_blocks
+      @advanced_search_blocks ||= default_hash(:never_a_key_like_this)
+    end
+
+    def default_hash(flat_key = :simple)
+      Hash.new { |h,k| 
+        h[k] = (k == flat_key ? [] : Hash.new { |nh,nk| nh[nk] = [] })
+      }
+    end
+
+    def attr_search(*attributes, type: :simple)
+      unless ([:simple] + self.reflections.keys).include?(type)
+        raise ArgumentError, 'incorect type given'
+      end
+
+      search_attributes_hash!(attributes, type, search_attributes)
+    end
+
+    def alias_advanced_search(attribute, type: :simple, &block)
+      advanced_search_blocks[type][attribute] = block
+    end
+
+    def search_attributes_hash!(attributes, type, hash = default_hash)
+      if type == :simple
+        hash[:simple] += attributes
+        hash[:simple] = hash[:simple].uniq
+      else
+        reflection = self.reflections[type]
+        macro      = reflection.macro
+        klass      = klass_for_reflection(reflection)
+
+        if macro == :has_many
+          macro = :has_many_through if reflection.options[:through]
+        end
+
+        hash[macro][type] += attributes
+        hash[macro][type] = hash[macro][type].uniq
+
+        unless klass.kind_of?(SearchMe::Search)
+          klass.extend(SearchMe::Search)
+        end
+      end
+      hash = sanitize_params!(hash)
+    end
+
+    def search_me(attribute, term)
+      self.where(simple_search_where_condition(attribute, term))
+    end
+
+    def join(array)
+      array.delete_if { |condition| condition.blank? }.join(joiner)
+    end
+
+    def search(term)
+      @joiner = :or
+      condition = join([
+        simple_search_condition(term), 
+        reflection_search_condition(term)
+      ])
+      self.where(condition)
+    end
+
+    def joiner 
+      @joiner ||= :or
+      " #{@joiner.upcase} "
+    end
+
+    def advanced_search(search_terms)
+      search_terms = sanitize_params!(search_terms) 
+      @joiner = :and
+
+      hash = default_hash
+      search_terms.each do |type, attributes|
+        search_attributes_hash!(attributes.keys,type,hash)
+      end
+      @this_search_attributes = hash
+
+      conditions = @this_search_attributes.keys.map { |type|
+        case type
+        when :simple
+          join(@this_search_attributes[type].map { |attribute|
+            term = search_terms[type][attribute]
+            if advanced_search_block_for?(type, attribute)
+              call_advanced_search_block_for(type, attribute, term)
+            else
+              simple_search_where_condition(attribute, term)           
+            end
+          })
+        when :belongs_to
+          self.advanced_search_reflection_group(type,search_terms) {
+            |reflection,objs|
+            "#{reflection.name}_id IN (#{object_ids(objs).join(',')})"
+          }
+        when :has_one
+          self.advanced_search_reflection_group(type,search_terms) {
+            |reflection,objs|
+            f_key = "#{name_for(reflection.active_record.name)}_id"
+
+            "id IN (#{object_ids(objs, f_key).join(',')})"
+          }
+        when :has_many
+          self.advanced_search_reflection_group(type,search_terms) {
+            |reflection,objs|
+            f_key = reflection.options
+              .fetch(:foreign_key) { "#{self.to_s.underscore}_id" }
+
+            "id IN (#{object_ids(objs, f_key).join(',')})"
+          }
+        when :has_many_through
+          warn 'WARNING: has_many_through relationships not available'
+        end
+      }
+      self.where(join(conditions))
+    end
+
+    def reflection_search_condition(term)
+      macro_groups = search_attributes
+      @this_search_attributes = macro_groups
+
+      condition = macro_groups.keys.map { |type|
+        case type
+        when :belongs_to
+          self.search_reflection_group(type, term) { |reflection, objs|
+            "#{reflection.name}_id IN (#{object_ids(objs).join(',')})"
+          }
+        when :has_many
+          self.search_reflection_group(type, term) { |reflection, objs|
+            f_key = reflection.options
+              .fetch(:foreign_key) { "#{self.to_s.underscore}_id" }
+
+            "id IN (#{object_ids(objs, f_key).join(',')})"
+          }
+        when :has_one
+          self.search_reflection_group(type, term) { |reflection, objs|
+            f_key = "#{name_for(reflection.active_record.name)}_id"
+
+            "id IN (#{object_ids(objs, f_key).join(',')})"
+          }
+        when :has_many_through
+          warn 'WARNING: has_many_through relationships not available'
+        end
+      }
+      join(condition)
+    end
+
+
+    def reflection_search(term)
+      self.where(reflection_search_condition(term))
+    end
+
+    def map_reflection_group(type, outer_block)
+      cond = @this_search_attributes[type].map {|reflection, attributes|
+        reflection = self.reflections[reflection]
+        klass      = klass_for_reflection(reflection)
+
+        reflection_condition = join(yield(attributes,klass,reflection))
+          
+        search_result = klass.where(reflection_condition)
+
+        outer_block.call(reflection, search_result)
+      }
+      join(cond)
+    end
+
+    def search_reflection_group(type, term, &block)
+      map_reflection_group(type, block) do |attributes,klass,reflection|
+        attributes.map { |attribute|
+          name = reflection.name
+          if advanced_search_block_for?(name, attribute)
+            call_advanced_search_block_for(name, attribute, term)
+          else
+            klass.simple_search_where_condition(attribute, term)
+          end
+        }
+      end
+    end
+
+    def advanced_search_reflection_group(type, search_terms, &block)
+      map_reflection_group(type, block) do |attributes,klass,reflection|
+        attributes.map { |attribute|
+          name = reflection.name
+          term = search_terms[name][attribute]
+          if advanced_search_block_for?(name, attribute)
+            call_advanced_search_block_for(name, attribute, term)
+          else
+            klass.simple_search_where_condition(attribute, term)
+          end
+        }
+      end
+    end
+
+    def simple_search_condition(term)
+      condition = search_attributes[:simple].map { |attribute|
+        simple_search_where_condition(attribute, term)
+      }
+      join(condition)
+    end
+
+    def simple_search(term)
+      self.where(simple_search_condition(term))
+    end
+
+    def simple_search_where_condition(attribute, term)
+      table_column = "#{self.table_name}.#{attribute}"
+      column = self.columns.find { |col| col.name == attribute.to_s }
+
+      case column.type
+      when :string, :integer, :text, :float, :decimal
+        "CAST(#{table_column} AS CHAR) LIKE '%#{term}%'"
+      when :boolean
+        term = {
+          true => "= 't'", false => "= 'f'", nil => 'IS NULL',
+          1 => "= 't'", 0 => "= 'f'", '1' => "= 't'", '0' => "= 'f'"
+        }.fetch(term) {
+          good_args = term.keys.map(:inspect).join(',')
+          error = "boolean column term must be #{good_args}"
+          raise ArgumentError, error
+        } 
+        "#{table_column} #{term}"
+      else
+        warn "#{column.type} type is not supported by SearchMe::Search"
+      end
+    end
+
+    def advanced_search_block_for?(type, attribute)
+      !advanced_search_blocks[type].blank? && 
+        !advanced_search_blocks[type][attribute].blank?
+    end
+
+    def call_advanced_search_block_for(type, attribute, term)
+      advanced_search_blocks[type][attribute].call(term)
+    end
+
+    def object_ids(objects, column = nil)
+      (column ? objects.map(&column.to_sym) : objects.ids) << -5318008 
+    end
+
+    def klass_for_reflection(reflection)
+      if name = reflection.options[:class_name]
+        constant_for(name)
+      else
+        constant_for(reflection.name)
+      end
+    end
+
+    def name_for(constant, plural: false)
+      name = constant.to_s.underscore
+      name = name.singularize unless plural
+      name
+    end
+
+    def constant_for(name)
+      name.to_s.camelize.singularize.constantize
+    end
+
+    def sanitize_params!(params)
+      params.to_hash.symbolize_keys!.each { |k,v| 
+        if v.is_a?(Hash)
+          params[k] = v = v.to_hash
+          sanitize_params!(v) and v.symbolize_keys!
+        end
+        params.delete(k) if v.blank? && !(v == false)
+      }
+    end
+  end
+end

data/lib/search_me.rb

@@ -0,0 +1,25 @@
+require_relative 'search_me/search'
+require_relative 'search_me/filters'
+
+module SearchMe
+
+  class Config
+    attr_accessor :time_field
+    def initialize
+      # Set Defaults
+      @time_field = :created_at
+
+      yield(self) if block_given?
+    end
+  end
+
+  extend self
+
+  def self.config(&block)
+    if block_given?
+      @config = Config.new(&block) 
+    else
+      @config ||= Config.new
+    end
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: search_me
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- jphager2
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-27 00:00:00.000000000 Z
+dependencies: []
+description: Uses LIKE to search attributes and return any objects of the model for
+  which a match is found
+email: jphager2@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/search_me.rb
+- lib/search_me/filters.rb
+- lib/search_me/search.rb
+homepage: https://github.com/jphager2/search_me
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Allows you to define attributes of active record model and its related models
+  which will be searched
+test_files: []