birddog 0.0.8 → 0.0.9.p1

data/birddog.gemspec

@@ -27,5 +27,4 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "chronic"
   s.add_runtime_dependency "activerecord"
   s.add_runtime_dependency "activesupport"
-  s.add_runtime_dependency "squeel"
 end

data/lib/birddog/birddog.rb

@@ -1,3 +1,5 @@
+require 'birddog/scope_builder'
+
 module Birddog
 
   def self.included(base)
@@ -23,7 +25,7 @@ module Birddog
 
     def field(name, options={}, &mapping)
       @fields[name] = field = {
-        :attribute       => options.fetch(:attribute, name),
+        :attribute       => field_attribute(name, options.fetch(:attribute, nil), options.fetch(:aggregate, nil)),
         :cast            => options.fetch(:cast, false),
         :type            => options.fetch(:type, :string),
         :case_sensitive  => options.fetch(:case_sensitive, true),
@@ -47,27 +49,36 @@ module Birddog
       aggregate?(name) ? define_aggregate_field(name, @fields[name]) : define_field(name, @fields[name])
     end
 
+    def aggregatable(*fields)
+      fields.flatten.compact.uniq.each do |agg_field|
+        averagable(agg_field)
+        minimumable(agg_field)
+        maximumable(agg_field)
+        sumable(agg_field)
+      end
+    end
+
     def averagable(*fields)
-      fields.flatten.each do |avg_field|
-        @averagable << avg_field
+      fields.flatten.compact.uniq.each do |avg_field|
+        @averagable << avg_field unless @averagable.include?(avg_field)
       end
     end
 
     def minimumable(*fields)
-      fields.flatten.each do |min_field|
-        @minimumable << min_field
+      fields.flatten.compact.uniq.each do |min_field|
+        @minimumable << min_field unless @minimumable.include?(min_field)
       end
     end
 
     def maximumable(*fields)
-      fields.flatten.each do |max_field|
-        @maximumable << max_field 
+      fields.flatten.compact.uniq.each do |max_field|
+        @maximumable << max_field unless @maximumable.include?(max_field)
       end
     end
 
     def sumable(*fields)
-      fields.flatten.each do |sum_field|
-        @sumable << sum_field
+      fields.flatten.compact.uniq.each do |sum_field|
+        @sumable << sum_field unless @sumable.include?(sum_field)
       end
     end
 
@@ -76,23 +87,26 @@ module Birddog
     end
 
     def search(query)
-      tokens = tokenize(query)
-      tokens.inject(@model) do |model, (key,value)|
-        key, value = "text_search", key if value.nil?
-        scope_for(model, key, value)
-      end
+      key, value = tokenize(query)
+      key, value = "text_search", key if value.nil?
+      scope_for(@model, key, value)
     end
 
-    def text_search(*fields)
-      options = fields.extract_options!
-      fields = fields.map { |f| "LOWER(#{f}) LIKE :value" }.join(" OR ")
+    ################## PRIVATES ####################
 
-      define_scope "text_search" do |value|
-        options.merge(:conditions => [fields, { :value => "%#{value.downcase}%" }])
-      end
+    def aggregate_and_aliased?(aggregate)
+      aggregate && aggregate.respond_to?(:alias) && aggregate.alias
     end
-
-    ################## PRIVATES ####################
+    private :aggregate_and_aliased?
+
+    def field_attribute(name, val, aggregate)
+      val = name.to_sym unless val
+      val = ::Arel::Nodes::SqlLiteral.new(aggregate.alias) if aggregate_and_aliased?(aggregate)
+      val = @model.arel_table[val] if val.is_a?(Symbol)
+      val = ::Arel::Nodes::SqlLiteral.new(val) if val.is_a?(String)
+      return val
+    end
+    private :field_attribute
 
     def conditional?(value)
       value.index(/[<>=]/) != nil   
@@ -103,18 +117,16 @@ module Birddog
       field[:options].merge!(:select => field[:aggregate])
 
       define_scope(name) do |value|
-        if conditional?(value)
-          field[:options].merge(:having => setup_conditions(field, value))
-        else
-          field[:options]
-        end
+        current_scope = ::Birddog::ScopeBuilder.build(@model, field[:options])
+        conditional?(value) ? setup_conditions(current_scope, field, value) : current_scope
       end
     end
     private :define_aggregate_field
 
     def define_field(name, field)
       define_scope(name) do |value|
-        field[:options].merge(:conditions => setup_conditions(field, value))
+        current_scope = ::Birddog::ScopeBuilder.build(@model, field[:options])
+        setup_conditions(current_scope, field, value)
       end
     end
     private :define_field
@@ -169,20 +181,20 @@ module Birddog
     end
     private :parse_condition
 
-    def setup_conditions(field, value)
+    def setup_conditions(current_scope, field, value)
       condition = parse_condition(value)
       value = callable_or_cast(field, condition, value) 
       value = field[:mapping].call(value)
 
       case field[:type]
       when :string then
-        conditions_for_string_search(field, value)
+        conditions_for_string_search(current_scope, field, condition, value)
       when :float, :decimal, :integer then
-        conditions_for_numeric(field, condition, value)
+        conditions_for_numeric(current_scope, field, condition, value, field[:type])
       when :date, :datetime, :time then 
-        conditions_for_date(field, condition, value)
+        conditions_for_date(current_scope, field, condition, value)
       else
-        { field[:attribute] => value }
+        current_scope.where(field[:attribute] => value)
       end
     end
     private :setup_conditions
@@ -191,7 +203,7 @@ module Birddog
       split_tokens = query.split(":")
       split_tokens.each { |tok| tok.strip! }
 
-      [[split_tokens.shift, split_tokens.join(":")]]
+      [split_tokens.shift, split_tokens.join(":")]
     end
     private :tokenize
 

data/lib/birddog/field_conditions.rb

@@ -2,51 +2,71 @@ module Birddog
 
   module FieldConditions
 
-    FieldConversions = {
-      :integer => lambda{ |v| v.to_i },
-      :decimal => lambda{ |v| v.to_f },
-      :float => lambda{ |v| v.to_f }
-    }
-
-    def conditions_for_string_search(field, value)
-      search_con = " LIKE ? "
-      field_to_search = "lower(#{field[:attribute]})"
-      value_to_search = value.downcase
-
-      if field[:case_sensitive]
-        field_to_search = field[:attribute]
-        value_to_search = value
-      end
+    def conditions_for_string_search(current_scope, field, condition, value)
+      search_con = condition
+      strict_equality = (search_con == "==")
+      value_to_search = (value ? value.dup : nil)
 
-      if field[:match_substring]
-        value_to_search = "%#{value_to_search}%"
-      end
+      if !strict_equality
+        if field[:match_substring]
+          search_con = "=~"
+          value_to_search = "%#{value_to_search}%"
+        end
 
-      if field[:regex] && regexed?(value)
-        # TODO check db driver to determine regex operator for DB (current is Postgres)
-        search_con = " ~ ? "
-        value_to_search = value[1..value.size-2]
-        field_to_search = field[:attribute]
-      elsif field[:wildcard] && value_to_search.include?("*")
-        value_to_search.gsub!(/[\*]/, "%")
+        if field[:regex] && regexed?(value)
+          # TODO check db driver to determine regex operator for DB (current is Postgres)
+          search_con = "=~"
+          value_to_search = value[1..value.size-2]
+        elsif field[:wildcard] && value_to_search.include?("*")
+          search_con = "=~"
+          value_to_search.gsub!(/[\*]/, "%")
+        end
       end
 
-      [ "#{field_to_search} #{search_con} ", value_to_search ]
+      conditionally_scoped(current_scope, field[:attribute], search_con, value_to_search, field[:aggregate])
+    end
+
+    def conditions_for_date(current_scope, field, condition, value)
+      conditionally_scoped(current_scope, field[:attribute], condition, value.value.strftime("%Y-%m-%d"), field[:aggregate])
     end
 
-    def conditions_for_date(field, condition, value)
-      [ "#{field[:attribute]} #{condition} ? ", value.value.strftime("%Y-%m-%d")]
+    def conditions_for_numeric(current_scope, field, condition, value, field_type)
+      conditionally_scoped(current_scope, field[:attribute], condition, cast_numeric(field_type, value), field[:aggregate], true)
     end
 
-    def conditions_for_numeric(field, condition, value)
-      db_value = FieldConversions[field[:type]].call(value)
+    def cast_numeric(field_type, value)
+      case field_type
+      when :integer then
+        value.to_i
+      else
+        value.to_f
+      end
+    end
 
-      case condition
+    def conditionally_scoped(current_scope, field, condition, value, aggregate, is_numeric = false)
+      having_or_where = (aggregate ? :having : :where)
+      scope = case condition
       when "=~", "~=" then
-        [ "ABS(#{field[:attribute]}) >= ? AND ABS(#{field[:attribute]}) < ?", db_value.abs.floor, (db_value.abs + 1).floor ]
+        if is_numeric
+          current_scope.__send__(having_or_where, field.gteq(value.floor).and(field.lt((value + 1).floor))) 
+        else
+          current_scope.__send__(having_or_where, field.matches(value))
+        end
+      when :<, "<" then
+        current_scope.__send__(having_or_where, field.lt(value))
+      when :>, ">" then
+        current_scope.__send__(having_or_where, field.gt(value))
+      when :<=, "<=", "=<" then
+        current_scope.__send__(having_or_where, field.lteq(value))
+      when :>=, ">=", "=>" then
+        current_scope.__send__(having_or_where, field.gteq(value))
+      when "=", "==" then
+        current_scope.__send__(having_or_where, field.eq(value))
       else
-        [ "#{field[:attribute]} #{condition} ? ", db_value]
+        raise "#{condition} not defined for #{field}"
       end
+
+      return scope
     end
 
     def regexed?(value)

data/lib/birddog/scope_builder.rb

@@ -0,0 +1,26 @@
+module Birddog
+
+  class ScopeBuilder
+
+    def self.build(model, scope_options)
+      new(model, scope_options).build
+    end
+    
+    def initialize(model, scope_options)
+      @options = scope_options
+      @model = model
+    end
+
+    def build
+      scope = @model.scoped
+      
+      @options.each do |k, v|
+        scope = scope.__send__(k, v)
+      end
+      
+      return scope
+    end
+
+  end
+  
+end

data/lib/birddog/version.rb

@@ -1,3 +1,3 @@
 module Birddog
-  VERSION = "0.0.8"
+  VERSION = "0.0.9.p1"
 end

data/lib/birddog.rb

@@ -17,11 +17,6 @@
 require 'chronic'
 require 'active_support/core_ext'
 require 'active_record'
-require 'squeel'
-
-Squeel.configure do |config|
-  config.load_core_extensions :hash  
-end
 
 require "birddog/version"
 require "birddog/field_conditions"

data/specs/birddog_spec.rb

@@ -36,11 +36,6 @@ describe Birddog::Birddog do ####################
     User.scopes_for_query("last_name:Doe").size.must_equal(1)
   end
 
-  it "can find using case insensitive search" do
-    User.scopes_for_query("insensitive_last_name:doe").must_include(@john)
-    User.scopes_for_query("insensitive_last_name:doe").size.must_equal(1)
-  end
-
   it "can find matching substrings" do
     User.scopes_for_query("substringed_last_name:oe").must_include(@john)
     User.scopes_for_query("substringed_last_name:oe").size.must_equal(1)

data/specs/spec_helper.rb

@@ -30,6 +30,24 @@ ActiveRecord::Schema.define(:version => 1) do
   end
 end
 
+class Product < ActiveRecord::Base
+  include Birddog
+
+  belongs_to :user
+
+  birddog do |search|
+    search.aggregatable :value
+    search.field :name, :regex => true, :wildcard => true
+    search.field :cast_val, :type => :decimal, :cast => lambda { |v| v }, :attribute => :value
+    search.field :value, :type => :decimal
+    search.field :available, :type => :boolean
+
+    search.keyword :sort do |value|
+      order(search.fields[value.to_sym][:attribute].desc)
+    end
+  end
+end
+
 class User < ActiveRecord::Base
   include Birddog
 
@@ -39,9 +57,9 @@ class User < ActiveRecord::Base
     search.field :first_name
     search.alias_field :name, :first_name
     search.field :last_name
-    search.field :total_product_value, :type => :decimal, :aggregate => "SUM(products.value) AS total_product_value"
-    search.field :insensitive_last_name, :attribute => "last_name", :case_sensitive => false
-    search.field :substringed_last_name, :attribute => "last_name", :match_substring => true
+    search.field :total_product_value, :type => :decimal, :aggregate => Product.arel_table[:value].sum.as("total_product_value")
+    search.field :insensitive_last_name, :attribute => arel_table[:last_name], :case_sensitive => false
+    search.field :substringed_last_name, :attribute => arel_table[:last_name], :match_substring => true
     search.field :available_product, :type => :boolean,
                                      :attribute => "products.available",
                                      :joins => :products
@@ -51,30 +69,5 @@ class User < ActiveRecord::Base
         joins("LEFT OUTER JOIN products AS products ON (products.user_id = users.id)").
         group(arel_table[:id])
     end
-
-    search.text_search "first_name", "last_name", "products.name", :include => :products
-  end
-end
-
-class Product < ActiveRecord::Base
-  include Birddog
-
-  belongs_to :user
-
-  birddog do |search|
-    search.averagable :value
-    search.minimumable :value
-    search.maximumable :value
-    search.sumable :value
-    search.text_search "products.name", "products.value"
-
-    search.field :name, :regex => true, :wildcard => true
-    search.field :cast_val, :type => :decimal, :cast => lambda { |v| v }, :attribute => :value
-    search.field :value, :type => :decimal
-    search.field :available, :type => :boolean
-
-    search.keyword :sort do |value|
-      { :order => "#{search.fields[value.to_sym][:attribute]} DESC" }
-    end
   end
 end

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: birddog
 version: !ruby/object:Gem::Version
-  version: 0.0.8
-  prerelease: 
+  version: 0.0.9.p1
+  prerelease: 6
 platform: ruby
 authors:
 - Brandon Dewitt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-03 00:00:00.000000000Z
+date: 2012-03-05 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &19678920 !ruby/object:Gem::Requirement
+  requirement: &17260400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *19678920
+  version_requirements: *17260400
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &19678160 !ruby/object:Gem::Requirement
+  requirement: &17259880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *19678160
+  version_requirements: *17259880
 - !ruby/object:Gem::Dependency
   name: sqlite3-ruby
-  requirement: &19677700 !ruby/object:Gem::Requirement
+  requirement: &17259400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *19677700
+  version_requirements: *17259400
 - !ruby/object:Gem::Dependency
   name: pry
-  requirement: &19677240 !ruby/object:Gem::Requirement
+  requirement: &17245300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *19677240
+  version_requirements: *17245300
 - !ruby/object:Gem::Dependency
   name: chronic
-  requirement: &19676800 !ruby/object:Gem::Requirement
+  requirement: &17244840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *19676800
+  version_requirements: *17244840
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &19676360 !ruby/object:Gem::Requirement
+  requirement: &17244300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *19676360
+  version_requirements: *17244300
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &19663100 !ruby/object:Gem::Requirement
+  requirement: &17243780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,18 +87,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *19663100
-- !ruby/object:Gem::Dependency
-  name: squeel
-  requirement: &19662480 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: *19662480
+  version_requirements: *17243780
 description: Seeeeeeeee Readme
 email:
 - brandonsdewitt@gmail.com
@@ -117,6 +106,7 @@ files:
 - lib/birddog/date_expression.rb
 - lib/birddog/field_conditions.rb
 - lib/birddog/numeric_expression.rb
+- lib/birddog/scope_builder.rb
 - lib/birddog/searchable.rb
 - lib/birddog/version.rb
 - specs/birddog_spec.rb
@@ -139,16 +129,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1270257218013225858
+      hash: 2755655051036560996
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: 1270257218013225858
+      version: 1.3.1
 requirements: []
 rubyforge_project: birddog
 rubygems_version: 1.8.10