search_cop 1.0.0

data/lib/search_cop/arel/visitors.rb

@@ -0,0 +1,223 @@
+
+module SearchCop
+  module Arel
+    module Visitors
+      module ToSql
+        if ::Arel::VERSION >= "4.0.1"
+          def visit_SearchCopGrammar_Nodes_And(o, a)
+            visit ::Arel::Nodes::Grouping.new(o.nodes.inject { |res, cur| ::Arel::Nodes::And.new [res, cur] }), a
+          end
+
+          def visit_SearchCopGrammar_Nodes_Or(o, a)
+            visit ::Arel::Nodes::Grouping.new(o.nodes.inject { |res, cur| ::Arel::Nodes::Or.new res, cur }), a
+          end
+
+          def visit_SearchCopGrammar_Nodes_Equality(o, a)
+            visit ::Arel::Nodes::Equality.new(o.left, o.right), a
+          end
+
+          def visit_SearchCopGrammar_Nodes_NotEqual(o, a)
+            visit ::Arel::Nodes::NotEqual.new(o.left, o.right), a
+          end
+
+          def visit_SearchCopGrammar_Nodes_LessThan(o, a)
+            visit ::Arel::Nodes::LessThan.new(o.left, o.right), a
+          end
+
+          def visit_SearchCopGrammar_Nodes_LessThanOrEqual(o, a)
+            visit ::Arel::Nodes::LessThanOrEqual.new(o.left, o.right), a
+          end
+
+          def visit_SearchCopGrammar_Nodes_GreaterThan(o, a)
+            visit ::Arel::Nodes::GreaterThan.new(o.left, o.right), a
+          end
+
+          def visit_SearchCopGrammar_Nodes_GreaterThanOrEqual(o, a)
+            visit ::Arel::Nodes::GreaterThanOrEqual.new(o.left, o.right), a
+          end
+
+          def visit_SearchCopGrammar_Nodes_Not(o, a)
+            visit ::Arel::Nodes::Not.new(o.object), a
+          end
+
+          def visit_SearchCopGrammar_Nodes_Matches(o, a)
+            visit ::Arel::Nodes::Matches.new(o.left, o.right), a
+          end
+        else
+          def visit_SearchCopGrammar_Nodes_And(o)
+            visit ::Arel::Nodes::Grouping.new(o.nodes.inject { |res, cur| ::Arel::Nodes::And.new [res, cur] })
+          end
+
+          def visit_SearchCopGrammar_Nodes_Or(o)
+            visit ::Arel::Nodes::Grouping.new(o.nodes.inject { |res, cur| ::Arel::Nodes::Or.new res, cur })
+          end
+
+          def visit_SearchCopGrammar_Nodes_Equality(o)
+            visit ::Arel::Nodes::Equality.new(o.left, o.right)
+          end
+
+          def visit_SearchCopGrammar_Nodes_NotEqual(o)
+            visit ::Arel::Nodes::NotEqual.new(o.left, o.right)
+          end
+
+          def visit_SearchCopGrammar_Nodes_LessThan(o)
+            visit ::Arel::Nodes::LessThan.new(o.left, o.right)
+          end
+
+          def visit_SearchCopGrammar_Nodes_LessThanOrEqual(o)
+            visit ::Arel::Nodes::LessThanOrEqual.new(o.left, o.right)
+          end
+
+          def visit_SearchCopGrammar_Nodes_GreaterThan(o)
+            visit ::Arel::Nodes::GreaterThan.new(o.left, o.right)
+          end
+
+          def visit_SearchCopGrammar_Nodes_GreaterThanOrEqual(o)
+            visit ::Arel::Nodes::GreaterThanOrEqual.new(o.left, o.right)
+          end
+
+          def visit_SearchCopGrammar_Nodes_Not(o)
+            visit ::Arel::Nodes::Not.new(o.object)
+          end
+
+          def visit_SearchCopGrammar_Nodes_Matches(o)
+            visit ::Arel::Nodes::Matches.new(o.left, o.right)
+          end
+        end
+      end
+
+      module MySQL
+        if ::Arel::VERSION >= "4.0.1"
+          def visit_SearchCopGrammar_Attributes_Collection(o, a)
+            o.attributes.collect { |attribute| visit attribute.attribute, a }.join(", ")
+          end
+
+          def visit_SearchCopGrammar_Nodes_FulltextExpression(o, a)
+            "MATCH(#{visit o.collection, a}) AGAINST(#{visit visit(o.node, a), a} IN BOOLEAN MODE)"
+          end
+
+          def visit_SearchCopGrammar_Nodes_MatchesFulltextNot(o, a)
+            o.right.split(/[\s+'"<>()~-]+/).collect { |word| "-#{word}" }.join(" ")
+          end
+
+          def visit_SearchCopGrammar_Nodes_MatchesFulltext(o, a)
+            words = o.right.split(/[\s+'"<>()~-]+/)
+
+            words.size > 1 ? "\"#{words.join " "}\"" : words.first
+          end
+
+          def visit_SearchCopGrammar_Nodes_And_Fulltext(o, a)
+            res = o.nodes.collect do |node|
+              if node.is_a?(SearchCopGrammar::Nodes::MatchesFulltextNot)
+                visit node, a
+              else
+                node.nodes.size > 1 ? "+(#{visit node, a})" : "+#{visit node, a}"
+              end
+            end
+
+            res.join " "
+          end
+
+          def visit_SearchCopGrammar_Nodes_Or_Fulltext(o, a)
+            o.nodes.collect { |node| "(#{visit node, a})" }.join(" ")
+          end
+        else
+          def visit_SearchCopGrammar_Attributes_Collection(o)
+            o.attributes.collect { |attribute| visit attribute.attribute }.join(", ")
+          end
+
+          def visit_SearchCopGrammar_Nodes_FulltextExpression(o)
+            "MATCH(#{visit o.collection}) AGAINST(#{visit visit(o.node)} IN BOOLEAN MODE)"
+          end
+
+          def visit_SearchCopGrammar_Nodes_MatchesFulltextNot(o)
+            o.right.split(/[\s+'"<>()~-]+/).collect { |word| "-#{word}" }.join(" ")
+          end
+
+          def visit_SearchCopGrammar_Nodes_MatchesFulltext(o)
+            words = o.right.split(/[\s+'"<>()~-]+/)
+
+            words.size > 1 ? "\"#{words.join " "}\"" : words.first
+          end
+
+          def visit_SearchCopGrammar_Nodes_And_Fulltext(o)
+            res = o.nodes.collect do |node|
+              if node.is_a?(SearchCopGrammar::Nodes::MatchesFulltextNot)
+                visit node
+              else
+                node.nodes.size > 1 ? "+(#{visit node})" : "+#{visit node}"
+              end
+            end
+
+            res.join " "
+          end
+
+          def visit_SearchCopGrammar_Nodes_Or_Fulltext(o)
+            o.nodes.collect { |node| "(#{visit node})" }.join(" ")
+          end
+        end
+      end
+
+      module PostgreSQL
+        if ::Arel::VERSION >= "4.0.1"
+          def visit_SearchCopGrammar_Attributes_Collection(o, a)
+            o.attributes.collect { |attribute| visit attribute.attribute, a }.join(" || ' ' || ")
+          end
+
+          def visit_SearchCopGrammar_Nodes_FulltextExpression(o, a)
+            dictionary = o.collection.options[:dictionary] || "simple"
+
+            "to_tsvector(#{visit dictionary, a}, #{visit o.collection, a}) @@ to_tsquery(#{visit dictionary, a}, #{visit visit(o.node, a), a})"
+          end
+
+          def visit_SearchCopGrammar_Nodes_MatchesFulltextNot(o, a)
+            "!'#{o.right}'"
+          end
+
+          def visit_SearchCopGrammar_Nodes_MatchesFulltext(o, a)
+            "'#{o.right.gsub /[\s&|!:'"]+/, " "}'"
+          end
+
+          def visit_SearchCopGrammar_Nodes_And_Fulltext(o, a)
+            o.nodes.collect { |node| "(#{visit node, a})" }.join(" & ")
+          end
+
+          def visit_SearchCopGrammar_Nodes_Or_Fulltext(o, a)
+            o.nodes.collect { |node| "(#{visit node, a})" }.join(" | ")
+          end
+        else
+          def visit_SearchCopGrammar_Attributes_Collection(o)
+            o.attributes.collect { |attribute| visit attribute.attribute }.join(" || ' ' || ")
+          end
+
+          def visit_SearchCopGrammar_Nodes_FulltextExpression(o)
+            dictionary = o.collection.options[:dictionary] || "simple"
+
+            "to_tsvector(#{visit dictionary.to_sym}, #{visit o.collection}) @@ to_tsquery(#{visit dictionary.to_sym}, #{visit visit(o.node)})" # to_sym fixes a 3.2 + postgres bug
+          end
+
+          def visit_SearchCopGrammar_Nodes_MatchesFulltextNot(o)
+            "!'#{o.right}'"
+          end
+
+          def visit_SearchCopGrammar_Nodes_MatchesFulltext(o)
+            "'#{o.right.gsub /[\s&|!:'"]+/, " "}'"
+          end
+
+          def visit_SearchCopGrammar_Nodes_And_Fulltext(o)
+            o.nodes.collect { |node| "(#{visit node})" }.join(" & ")
+          end
+
+          def visit_SearchCopGrammar_Nodes_Or_Fulltext(o)
+            o.nodes.collect { |node| "(#{visit node})" }.join(" | ")
+          end
+        end
+      end
+    end
+  end
+end
+
+Arel::Visitors::PostgreSQL.send :include, SearchCop::Arel::Visitors::PostgreSQL
+Arel::Visitors::MySQL.send :include, SearchCop::Arel::Visitors::MySQL
+Arel::Visitors::ToSql.send :include, SearchCop::Arel::Visitors::ToSql
+

data/lib/search_cop/arel.rb

@@ -0,0 +1,4 @@
+
+require "arel"
+require "search_cop/arel/visitors"
+

data/lib/search_cop/grammar_parser.rb

@@ -0,0 +1,22 @@
+
+require "search_cop_grammar"
+require "treetop"
+
+Treetop.load File.expand_path("../../search_cop_grammar.treetop", __FILE__)
+
+module SearchCop
+  class GrammarParser
+    attr_reader :query_info
+
+    def initialize(query_info)
+      @query_info = query_info
+    end
+
+    def parse(string)
+      node = SearchCopGrammarParser.new.parse(string) || raise(ParseError)
+      node.query_info = query_info
+      node.evaluate
+    end
+  end
+end
+

data/lib/search_cop/hash_parser.rb

@@ -0,0 +1,42 @@
+
+class SearchCop::HashParser
+  attr_reader :query_info
+
+  def initialize(query_info)
+    @query_info = query_info
+  end
+
+  def parse(hash)
+    res = hash.collect do |key, value|
+      case key
+        when :and
+          value.collect { |val| parse val }.inject(:and)
+        when :or
+          value.collect { |val| parse val }.inject(:or)
+        when :not
+          parse(value).not
+        when :query
+          SearchCop::Parser.parse value, query_info
+        else
+          parse_attribute key, value
+      end
+    end
+
+    res.inject :and
+  end
+
+  private
+
+  def parse_attribute(key, value)
+    collection = SearchCopGrammar::Attributes::Collection.new(query_info, key.to_s)
+
+    if value.is_a?(Hash)
+      raise(SearchCop::ParseError, "Unknown operator #{value.keys.first}") unless [:matches, :eq, :not_eq, :gt, :gteq, :lt, :lteq].include?(value.keys.first)
+
+      collection.send value.keys.first, value.values.first.to_s
+    else
+      collection.send :matches, value.to_s
+    end
+  end
+end
+

data/lib/search_cop/query_builder.rb

@@ -0,0 +1,26 @@
+
+module SearchCop
+  class QueryBuilder
+    attr_accessor :query_info, :scope, :sql
+
+    def initialize(model, query, scope)
+      self.scope = scope
+      self.query_info = QueryInfo.new(model, scope)
+
+      arel = SearchCop::Parser.parse(query, query_info).optimize!
+
+      self.sql = model.connection.visitor.accept(arel)
+    end
+
+    def associations
+      all_associations - [query_info.model.name.tableize.to_sym]
+    end
+
+    private
+
+    def all_associations
+      scope.reflection.attributes.values.flatten.uniq.collect { |column| column.split(".").first }.collect { |column| scope.reflection.aliases[column] || column.to_sym }
+    end
+  end
+end
+

data/lib/search_cop/query_info.rb

@@ -0,0 +1,13 @@
+
+module SearchCop
+  class QueryInfo
+    attr_accessor :model, :scope, :references
+
+    def initialize(model, scope)
+      self.model = model
+      self.scope = scope
+      self.references = []
+    end
+  end
+end
+

data/lib/search_cop/search_scope.rb

@@ -0,0 +1,62 @@
+
+module SearchCop
+  class Reflection
+    attr_accessor :attributes, :options, :aliases, :scope
+
+    def initialize
+      self.attributes = {}
+      self.options = {}
+      self.aliases = {}
+    end
+
+    def default_attributes
+      keys = options.select { |key, value| value[:default] == true }.keys
+      keys = attributes.keys.reject { |key| options[key] && options[key][:default] == false } if keys.empty?
+      keys = keys.to_set
+
+      attributes.select { |key, value| keys.include? key }
+    end
+  end
+
+  class SearchScope
+    attr_accessor :name, :model, :reflection
+
+    def initialize(name, model)
+      self.model = model
+      self.reflection = Reflection.new
+    end
+
+    def attributes(*args)
+      args.each do |arg|
+        attributes_hash arg.is_a?(Hash) ? arg : { arg => arg }
+      end 
+    end
+
+    def options(key, options = {})
+      reflection.options[key.to_s] = (reflection.options[key.to_s] || {}).merge(options)
+    end
+
+    def aliases(hash)
+      hash.each do |key, value|
+        reflection.aliases[key.to_s] = value.respond_to?(:table_name) ? value.table_name : value.to_s
+      end
+    end
+
+    def scope(&block)
+      reflection.scope = block
+    end
+
+    private
+
+    def attributes_hash(hash)
+      hash.each do |key, value|
+        reflection.attributes[key.to_s] = Array(value).collect do |column|
+          table, attribute = column.to_s =~ /\./ ? column.to_s.split(".") : [model.name.tableize, column]
+
+          "#{table}.#{attribute}"
+        end 
+      end 
+    end
+  end
+end
+

data/lib/search_cop/version.rb

@@ -0,0 +1,3 @@
+module SearchCop
+  VERSION = "1.0.0"
+end

data/lib/search_cop.rb

@@ -0,0 +1,71 @@
+
+require "search_cop/version"
+require "search_cop/arel"
+require "search_cop/search_scope"
+require "search_cop/query_info"
+require "search_cop/query_builder"
+require "search_cop/grammar_parser"
+require "search_cop/hash_parser"
+
+module SearchCop
+  class SpecificationError < StandardError; end
+  class UnknownAttribute < SpecificationError; end
+
+  class RuntimeError < StandardError; end
+  class UnknownColumn < RuntimeError; end
+  class NoSearchableAttributes < RuntimeError; end
+  class IncompatibleDatatype < RuntimeError; end
+  class ParseError < RuntimeError; end
+
+  module Parser
+    def self.parse(query, query_info)
+      if query.is_a?(Hash)
+        SearchCop::HashParser.new(query_info).parse(query)
+      else
+        SearchCop::GrammarParser.new(query_info).parse(query)
+      end
+    end
+  end
+
+  def self.included(base)
+    base.extend ClassMethods
+
+    base.class_attribute :search_scopes
+    base.search_scopes = {}
+
+    base.search_scopes[:search] = SearchScope.new(:search, base)
+  end
+
+  module ClassMethods
+    def search_scope(name, &block)
+      search_scope = search_scopes[name] || SearchScope.new(name, self)
+      search_scope.instance_exec(&block)
+
+      search_scopes[name] = search_scope
+
+      self.class.send(:define_method, name) { |query| search_cop query, name }
+      self.class.send(:define_method, "unsafe_#{name}") { |query| unsafe_search_cop query, name }
+    end
+
+    def search_reflection(scope_name)
+      search_scopes[scope_name].reflection
+    end
+
+    def search_cop(query, scope_name)
+      unsafe_search_cop query, scope_name
+    rescue SearchCop::RuntimeError
+      respond_to?(:none) ? none : where("1 = 0")
+    end
+
+    def unsafe_search_cop(query, scope_name)
+      return respond_to?(:scoped) ? scoped : all if query.blank?
+
+      query_builder = QueryBuilder.new(self, query, search_scopes[scope_name])
+
+      scope = search_scopes[scope_name].reflection.scope ? instance_exec(&search_scopes[scope_name].reflection.scope) : eager_load(query_builder.associations)
+
+      scope.where query_builder.sql
+    end
+  end
+end
+

data/lib/search_cop_grammar/attributes.rb

@@ -0,0 +1,229 @@
+
+require "treetop"
+
+module SearchCopGrammar
+  module Attributes
+    class Collection
+      attr_reader :query_info, :key
+
+      def initialize(query_info, key)
+        raise(SearchCop::UnknownColumn, "Unknown column #{key}") unless query_info.scope.reflection.attributes[key]
+
+        @query_info = query_info
+        @key = key
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && [query_info.model, key] == [query_info.model, other.key]
+      end
+
+      def hash
+        [query_info.model, key].hash
+      end
+
+      [:eq, :not_eq, :lt, :lteq, :gt, :gteq].each do |method|
+         define_method method do |value|
+           attributes.collect! { |attribute| attribute.send method, value }.inject(:or)
+         end
+      end
+
+      def matches(value)
+        if fulltext?
+          SearchCopGrammar::Nodes::MatchesFulltext.new self, value.to_s
+        else
+          attributes.collect! { |attribute| attribute.matches value }.inject(:or)
+        end
+      end
+
+      def fulltext?
+        (query_info.scope.reflection.options[key] || {})[:type] == :fulltext
+      end
+
+      def compatible?(value)
+        attributes.all? { |attribute| attribute.compatible? value }
+      end
+
+      def options
+        query_info.scope.reflection.options[key]
+      end
+
+      def attributes
+        @attributes ||= query_info.scope.reflection.attributes[key].collect { |attribute_definition| attribute_for attribute_definition }
+      end
+
+      def klass_for(table)
+        klass = query_info.scope.reflection.aliases[table]
+        klass ||= table
+
+        query_info.model.reflections[klass.to_sym] ? query_info.model.reflections[klass.to_sym].klass : klass.classify.constantize
+      end
+
+      def alias_for(table)
+        (query_info.scope.reflection.aliases[table] && table) || klass_for(table).table_name
+      end
+
+      def attribute_for(attribute_definition)
+        query_info.references.push attribute_definition
+
+        table, column = attribute_definition.split(".")
+        klass = klass_for(table)
+
+        raise(SearchCop::UnknownAttribute, "Unknown attribute #{attribute_definition}") unless klass.columns_hash[column]
+
+        Attributes.const_get(klass.columns_hash[column].type.to_s.classify).new(klass.arel_table.alias(alias_for(table))[column], klass, options)
+      end
+    end
+
+    class Base
+      attr_reader :attribute, :options
+
+      def initialize(attribute, klass, options = {})
+        @attribute = attribute
+        @klass = klass
+        @options = (options || {})
+      end
+
+      def map(value)
+        value
+      end
+
+      def compatible?(value)
+        map value
+
+        true
+      rescue SearchCop::IncompatibleDatatype
+        false
+      end
+
+      def fulltext?
+        false
+      end
+
+      { :eq => "Equality", :not_eq => "NotEqual", :lt => "LessThan", :lteq => "LessThanOrEqual", :gt => "GreaterThan", :gteq => "GreaterThanOrEqual", :matches => "Matches" }.each do |method, class_name|
+        define_method method do |value|
+          raise(SearchCop::IncompatibleDatatype, "Incompatible datatype for #{value}") unless compatible?(value)
+
+          SearchCopGrammar::Nodes.const_get(class_name).new(@attribute, map(value))
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        @attribute.send name, *args, &block
+      end
+
+      def respond_to?(*args)
+        @attribute.respond_to? *args
+      end
+    end
+
+    class String < Base
+      def matches_value(value)
+        return value.gsub(/\*/, "%") if (options[:left_wildcard] != false && value.strip =~ /^[^*]+\*$|^\*[^*]+$/) || value.strip =~ /^[^*]+\*$/
+
+        options[:left_wildcard] != false ? "%#{value}%" : "#{value}%"
+      end
+
+      def matches(value)
+        super matches_value(value)
+      end
+    end
+
+    class Text < String; end
+
+    class WithoutMatches < Base
+      def matches(value)
+        eq value
+      end
+    end
+
+    class Float < WithoutMatches
+      def compatible?(value)
+        return true if value.to_s =~ /^[0-9]+(\.[0-9]+)?$/
+
+        false
+      end
+    end
+
+    class Integer < Float; end
+    class Decimal < Float; end
+
+    class Datetime < WithoutMatches
+      def parse(value)
+        return value .. value unless value.is_a?(::String)
+
+        if value =~ /^[0-9]{4,}$/
+          ::Time.new(value).beginning_of_year .. ::Time.new(value).end_of_year
+        elsif value =~ /^([0-9]{4,})(\.|-|\/)([0-9]{1,2})$/
+          ::Time.new($1, $3, 15).beginning_of_month .. ::Time.new($1, $3, 15).end_of_month
+        elsif value =~ /^([0-9]{1,2})(\.|-|\/)([0-9]{4,})$/
+          ::Time.new($3, $1, 15).beginning_of_month .. ::Time.new($3, $1, 15).end_of_month
+        elsif value !~ /:/
+          time = ::Time.parse(value)
+          time.beginning_of_day .. time.end_of_day
+        else
+          time = ::Time.parse(value)
+          time .. time
+        end
+      rescue ArgumentError
+        raise SearchCop::IncompatibleDatatype, "Incompatible datatype for #{value}"
+      end
+
+      def map(value)
+        parse(value).first
+      end
+
+      def eq(value)
+        between parse(value)
+      end
+
+      def not_eq(value)
+        between(parse(value)).not
+      end
+
+      def gt(value)
+        super parse(value).last
+      end
+
+      def between(range)
+        gteq(range.first).and(lteq(range.last))
+      end
+    end
+
+    class Timestamp < Datetime; end
+
+    class Date < Datetime
+      def parse(value)
+        return value .. value unless value.is_a?(::String)
+
+        if value =~ /^[0-9]{4,}$/
+          ::Date.new(value.to_i).beginning_of_year .. ::Date.new(value.to_i).end_of_year
+        elsif value =~ /^([0-9]{4,})(\.|-|\/)([0-9]{1,2})$/
+          ::Date.new($1.to_i, $3.to_i, 15).beginning_of_month .. ::Date.new($1.to_i, $3.to_i, 15).end_of_month
+        elsif value =~ /^([0-9]{1,2})(\.|-|\/)([0-9]{4,})$/
+          ::Date.new($3.to_i, $1.to_i, 15).beginning_of_month .. ::Date.new($3.to_i, $1.to_i, 15).end_of_month
+        else
+          date = ::Date.parse(value)
+          date .. date
+        end
+      rescue ArgumentError
+        raise SearchCop::IncompatibleDatatype, "Incompatible datatype for #{value}"
+      end
+    end
+
+    class Time < Datetime; end
+
+    class Boolean < WithoutMatches
+      def map(value)
+        return true if value.to_s =~ /^(1|true|yes)$/i
+        return false if value.to_s =~ /^(0|false|no)$/i
+
+        raise SearchCop::IncompatibleDatatype, "Incompatible datatype for #{value}"
+      end
+    end
+  end
+end
+