attr_searchable 0.0.1

data/lib/attr_searchable/arel/visitors.rb

@@ -0,0 +1,159 @@
+
+module AttrSearchable
+  module Arel
+    module Visitors
+      module ToSql
+        if ::Arel::VERSION >= "4.0.1"
+          def visit_AttrSearchableGrammar_Nodes_And(o, a)
+            visit ::Arel::Nodes::Grouping.new(o.to_arel), a
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_Or(o, a)
+            visit ::Arel::Nodes::Grouping.new(o.to_arel), a
+          end
+        else
+          def visit_AttrSearchableGrammar_Nodes_And(o)
+            visit ::Arel::Nodes::Grouping.new(o.to_arel)
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_Or(o)
+            visit ::Arel::Nodes::Grouping.new(o.to_arel)
+          end
+        end
+      end
+
+      module MySQL
+        if ::Arel::VERSION >= "4.0.1"
+          def visit_AttrSearchableGrammar_Attributes_Collection(o, a)
+            o.attributes.collect { |attribute| visit attribute.attribute, a }.join(", ")
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_FulltextExpression(o, a)
+            "MATCH(#{visit o.collection, a}) AGAINST(#{visit visit(o.node, a), a} IN BOOLEAN MODE)"
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_MatchesFulltextNot(o, a)
+            o.right.split(/[\s+'"<>()~-]+/).collect { |word| "-#{word}" }.join(" ")
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_MatchesFulltext(o, a)
+            words = o.right.split(/[\s+'"<>()~-]+/)
+
+            words.size > 1 ? "\"#{words.join " "}\"" : words.first
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_And_Fulltext(o, a)
+            res = o.nodes.collect do |node|
+              if node.is_a?(AttrSearchableGrammar::Nodes::MatchesFulltextNot)
+                visit node, a
+              else
+                node.nodes.size > 1 ? "+(#{visit node, a})" : "+#{visit node, a}"
+              end
+            end
+
+            res.join " "
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_Or_Fulltext(o, a)
+            o.nodes.collect { |node| "(#{visit node, a})" }.join(" ")
+          end
+        else
+          def visit_AttrSearchableGrammar_Attributes_Collection(o)
+            o.attributes.collect { |attribute| visit attribute.attribute }.join(", ")
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_FulltextExpression(o)
+            "MATCH(#{visit o.collection}) AGAINST(#{visit visit(o.node)} IN BOOLEAN MODE)"
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_MatchesFulltextNot(o)
+            o.right.split(/[\s+'"<>()~-]+/).collect { |word| "-#{word}" }.join(" ")
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_MatchesFulltext(o)
+            words = o.right.split(/[\s+'"<>()~-]+/)
+
+            words.size > 1 ? "\"#{words.join " "}\"" : words.first
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_And_Fulltext(o)
+            res = o.nodes.collect do |node|
+              if node.is_a?(AttrSearchableGrammar::Nodes::MatchesFulltextNot)
+                visit node
+              else
+                node.nodes.size > 1 ? "+(#{visit node})" : "+#{visit node}"
+              end
+            end
+
+            res.join " "
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_Or_Fulltext(o)
+            o.nodes.collect { |node| "(#{visit node})" }.join(" ")
+          end
+        end
+      end
+
+      module PostgreSQL
+        if ::Arel::VERSION >= "4.0.1"
+          def visit_AttrSearchableGrammar_Attributes_Collection(o, a)
+            o.attributes.collect { |attribute| visit attribute.attribute, a }.join(" || ' ' || ")
+          end
+
+          def visit_AttrSearchableGrammar_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_AttrSearchableGrammar_Nodes_MatchesFulltextNot(o, a)
+            "!'#{o.right}'"
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_MatchesFulltext(o, a)
+            "'#{o.right.gsub /[\s&|!:'"]+/, " "}'"
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_And_Fulltext(o, a)
+            o.nodes.collect { |node| "(#{visit node, a})" }.join(" & ")
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_Or_Fulltext(o, a)
+            o.nodes.collect { |node| "(#{visit node, a})" }.join(" | ")
+          end
+        else
+          def visit_AttrSearchableGrammar_Attributes_Collection(o)
+            o.attributes.collect { |attribute| visit attribute.attribute }.join(" || ' ' || ")
+          end
+
+          def visit_AttrSearchableGrammar_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_AttrSearchableGrammar_Nodes_MatchesFulltextNot(o)
+            "!'#{o.right}'"
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_MatchesFulltext(o)
+            "'#{o.right.gsub /[\s&|!:'"]+/, " "}'"
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_And_Fulltext(o)
+            o.nodes.collect { |node| "(#{visit node})" }.join(" & ")
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_Or_Fulltext(o)
+            o.nodes.collect { |node| "(#{visit node})" }.join(" | ")
+          end
+        end
+      end
+    end
+  end
+end
+
+Arel::Visitors::PostgreSQL.send :include, AttrSearchable::Arel::Visitors::PostgreSQL
+Arel::Visitors::MySQL.send :include, AttrSearchable::Arel::Visitors::MySQL
+Arel::Visitors::ToSql.send :include, AttrSearchable::Arel::Visitors::ToSql
+

data/lib/attr_searchable/arel.rb

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

data/lib/attr_searchable/hash_parser.rb

@@ -0,0 +1,40 @@
+
+class AttrSearchable::HashParser
+  def initialize(model)
+    @model = model
+  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
+          AttrSearchable::Parser.parse value, @model
+        else
+          parse_attribute key, value
+      end
+    end
+
+    res.inject :and
+  end
+
+  private
+
+  def parse_attribute(key, value)
+    collection = AttrSearchableGrammar::Attributes::Collection.new(@model, key.to_s)
+
+    if value.is_a?(Hash)
+      raise AttrSearchable::ParseError 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/attr_searchable/version.rb

@@ -0,0 +1,3 @@
+module AttrSearchable
+  VERSION = "0.0.1"
+end

data/lib/attr_searchable.rb

@@ -0,0 +1,76 @@
+
+require "attr_searchable/version"
+require "attr_searchable/arel"
+require "attr_searchable_grammar"
+require "attr_searchable/hash_parser"
+require "treetop"
+
+Treetop.load File.expand_path("../attr_searchable_grammar.treetop", __FILE__)
+
+module AttrSearchable
+  class Error < StandardError; end
+  class UnknownColumn < Error; end
+  class NoSearchableAttributes < Error; end
+  class IncompatibleDatatype < Error; end
+  class ParseError < Error; end
+
+  module Parser
+    def self.parse(arg, model)
+      arg.is_a?(Hash) ? parse_hash(arg, model) : parse_string(arg, model)
+    end
+
+    def self.parse_hash(hash, model)
+      AttrSearchable::HashParser.new(model).parse(hash) || raise(ParseError)
+    end
+
+    def self.parse_string(string, model)
+      node = AttrSearchableGrammarParser.new.parse(string) || raise(ParseError)
+      node.model = model
+      node.to_arel
+    end
+  end
+
+  def self.included(base)
+    base.class_attribute :searchable_attributes
+    base.searchable_attributes = {}
+
+    base.class_attribute :searchable_attribute_options
+    base.searchable_attribute_options = {}
+
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def attr_searchable(*args)
+      args.each do |arg|
+        attr_searchable_hash arg.is_a?(Hash) ? arg : { arg => arg }
+      end
+    end
+
+    def attr_searchable_hash(hash)
+      hash.each do |key, value|
+        self.searchable_attributes[key.to_s] = Array(value).collect do |column|
+          table, attribute = column.to_s =~ /\./ ? column.to_s.split(".") : [name, column]
+
+          "#{table.tableize}.#{attribute}"
+        end
+      end
+    end
+
+    def attr_searchable_options(key, options = {})
+      self.searchable_attribute_options[key.to_s] = (self.searchable_attribute_options[key.to_s] || {}).merge(options)
+    end
+
+    def search(arg)
+      return respond_to?(:scoped) ? scoped : all if arg.blank?
+
+      scope = respond_to?(:search_scope) ? search_scope : nil
+      scope ||= eager_load(searchable_attributes.values.flatten.uniq.collect { |column| column.split(".").first.to_sym } - [name.tableize.to_sym])
+
+      scope.where AttrSearchable::Parser.parse(arg, self).optimize!
+    rescue AttrSearchable::Error
+      respond_to?(:none) ? none : where("1 = 0")
+    end
+  end
+end
+

data/lib/attr_searchable_grammar/attributes.rb

@@ -0,0 +1,196 @@
+
+require "treetop"
+
+module AttrSearchableGrammar
+  module Attributes
+    class Collection
+      attr_reader :model, :key
+
+      def initialize(model, key)
+        raise AttrSearchable::IncompatibleDatatype unless model.searchable_attributes[key]
+
+        @model = model
+        @key = key
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && [model, key] == [other.model, other.key]
+      end
+
+      def hash
+        [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?
+          AttrSearchableGrammar::Nodes::MatchesFulltext.new self, value.to_s
+        else
+          attributes.collect! { |attribute| attribute.matches value }.inject(:or)
+        end
+      end
+
+      def fulltext?
+        (model.searchable_attribute_options[key] || {})[:type] == :fulltext
+      end
+
+      def compatible?(value)
+        attributes.all? { |attribute| attribute.compatible? value }
+      end
+
+      def options
+        model.searchable_attribute_options[key]
+      end
+
+      def attributes
+        @attributes ||= model.searchable_attributes[key].collect do |attribute|
+          table, column = attribute.split(".")
+          klass = table.classify.constantize
+
+          Attributes.const_get(klass.columns_hash[column].type.to_s.classify).new(klass.arel_table.alias(klass.table_name)[column], klass, options)
+        end
+      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 AttrSearchable::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 AttrSearchable::IncompatibleDatatype unless compatible?(value)
+
+          AttrSearchableGrammar::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 AttrSearchable::IncompatibleDatatype
+      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 between(range)
+        gteq(range.first).and(lteq(range.last))
+      end
+    end
+
+    class Timestamp < Datetime; end
+
+    class Date < Datetime
+      def parse(value)
+        dates = super(value).collect { |time| ::Time.parse(time).to_date }
+        dates.first .. dates.last
+      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 AttrSearchable::IncompatibleDatatype
+      end 
+    end
+  end
+end
+

data/lib/attr_searchable_grammar/nodes.rb

@@ -0,0 +1,167 @@
+
+require "treetop"
+
+module AttrSearchableGrammar
+  module Nodes
+    module Base
+      def and(node)
+        And.new self, node
+      end
+
+      def or(node)
+        Or.new self, node
+      end
+
+      def not
+        Not.new self
+      end
+
+      def can_flatten?
+        false
+      end
+
+      def flatten!
+        self
+      end
+
+      def can_group?
+        false
+      end
+
+      def group!
+        self
+      end
+
+      def fulltext?
+        false
+      end
+
+      def can_optimize?
+        can_flatten? || can_group?
+      end
+
+      def optimize!
+        flatten!.group! while can_optimize?
+
+        finalize!
+      end
+
+      def finalize!
+        self
+      end
+
+      def nodes
+        []
+      end
+    end
+
+    ["Equality", "NotEqual", "GreaterThan", "LessThan", "GreaterThanOrEqual", "LessThanOrEqual", "Matches", "Not"].each do |name|
+      const_set name, Class.new(Arel::Nodes.const_get(name))
+      const_get(name).send :include, Base
+    end
+
+    class MatchesFulltext < Arel::Nodes::Binary
+      include Base
+
+      def not
+        MatchesFulltextNot.new left, right
+      end
+
+      def fulltext?
+        true
+      end
+
+      def finalize!
+        FulltextExpression.new collection, self
+      end
+
+      def collection
+        left
+      end
+    end
+
+    class MatchesFulltextNot < MatchesFulltext; end
+
+    class FulltextExpression < Arel::Nodes::Node
+      include Base
+
+      attr_reader :collection, :node
+
+      def initialize(collection, node)
+        @collection = collection
+        @node = node
+      end
+    end
+
+    class Collection < Arel::Nodes::Node
+      include Base
+
+      attr_reader :nodes
+
+      def initialize(*nodes)
+        @nodes = nodes.flatten
+      end
+
+      def can_flatten?
+        nodes.any?(&:can_flatten?) || nodes.any? { |node| node.is_a?(self.class) || node.nodes.size == 1 }
+      end
+
+      def flatten!(&block)
+        @nodes = nodes.collect(&:flatten!).collect { |node| node.is_a?(self.class) || node.nodes.size == 1 ? node.nodes : node }.flatten
+
+        self
+      end
+
+      def can_group?
+        nodes.reject(&:fulltext?).any?(&:can_group?) || nodes.select(&:fulltext?).group_by(&:collection).any? { |_, group| group.size > 1 }
+      end
+
+      def group!
+        @nodes = nodes.reject(&:fulltext?).collect(&:group!) + nodes.select(&:fulltext?).group_by(&:collection).collect { |collection, group| group.size > 1 ? self.class::Fulltext.new(collection, group) : group.first }
+
+        self
+      end
+
+      def finalize!
+        @nodes = nodes.collect(&:finalize!)
+
+        self
+      end
+    end
+
+    class FulltextCollection < Collection
+      attr_reader :collection
+
+      def initialize(collection, *nodes)
+        @collection = collection
+
+        super *nodes
+      end
+
+      def fulltext?
+        true
+      end
+
+      def finalize!
+        FulltextExpression.new collection, self
+      end
+    end
+
+    class And < Collection
+      class Fulltext < FulltextCollection; end
+
+      def to_arel
+        nodes.inject { |res, cur| Arel::Nodes::And.new [res, cur] }
+      end
+    end
+
+    class Or < Collection
+      class Fulltext < FulltextCollection; end
+
+      def to_arel
+        nodes.inject { |res, cur| Arel::Nodes::Or.new res, cur }
+      end
+    end
+  end
+end
+