sprsquish-conditions_fu 0.2.0

data/TODO.txt

@@ -0,0 +1,21 @@
+- make 'any' work even when the same attribute_query is specified twice: 
+  * Person.any(:conditions => { :first_name.eql => "Bob", :first_name.eql => "Nathan" }) (?)
+  * Person.any(:conditions => { :first_name.eql => ["Bob", "Nathan"] })
+- make it work with objects that include all types of eager loaded associations (?)
+- include support for joined or included attributes (?)
+
+=== Notes on Find Hierarchy ===
+
+activerecord/base.rb
+  find (line 581)
+    find_every (line 1484)
+      construct_finder_sql (line 1615)
+        add_conditions! (line 1729)
+            merge_conditions (line 1436)
+              sanitize_sql_for_conditions (line 2068)
+                sanitize_sql_hash_for_conditions (line 2139)
+                   attribute_condition (line 1855)
+            
+
+activerecord/associations
+  find_with_associations (line 1247)

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 2
+:patch: 0

data/lib/conditions_fu.rb

@@ -0,0 +1,122 @@
+module ConditionsFu
+  module Base
+    # overriden sanitization in order to highjack the way that the condition string is formed
+    # the attribute_condition method needs to have the attribute query object in order to
+    # determine which operator to apply for the condition
+    # alias_method_chain :sanitize_sql_hash_for_conditions, :attribute_queries
+    def sanitize_sql_hash_for_conditions_with_attribute_queries(attrs, table_name = quoted_table_name)
+      condition_join_string = attrs.delete(:connect) || ' AND ' # ' OR ' or ' AND '
+      attrs = expand_hash_conditions_for_aggregates(attrs)
+      # view_statement("[sanitize] initial attrs", attrs)
+
+      conditions = attrs.map do |attr, value|
+        unless value.is_a?(Hash)
+          attr_string = attr.to_s
+
+          # Extract table name from qualified attribute names.
+          if attr_string.include?('.')
+            table_name, attr_string = attr_string.split('.', 2)
+            table_name = connection.quote_table_name(table_name)
+          end
+
+          # Here is the where the difference occurs: attribute_condition_for_query takes in the attr object
+          # table_name.`quoted_attribute_name` [result of attribute_condition_for_query]
+          attribute_condition_for_query("#{table_name}.#{connection.quote_column_name(attr_string)}", attr, value)
+        else
+          sanitize_sql_hash_for_conditions(value, connection.quote_table_name(attr.to_s))
+        end
+      end.join(condition_join_string)
+
+      # view_statement("[sanitize] conditions", conditions)
+      # view_statement("[sanitize] attrs values", attrs.values)
+      final_result = replace_bind_variables(conditions, expand_range_bind_variables(attrs.values))
+      # view_statement("[sanitize] final result", final_result)
+    end
+
+    # returns the operator and value portion of the query string for a given condition (i.e "= ?")
+    # the actual operator is determined by the attribute_query type ( i.e :name.gt => '>' )
+    def attribute_condition_for_query(column, attribute_query, value)
+      # immediately return to regularly scheduled programming if the attribute is a plain old symbol
+      return "#{column} #{attribute_condition(value)}" unless attribute_query.kind_of?(AttributeCondition)
+      return "MATCH(#{column}) AGAINST(? IN BOOLEAN MODE)" if attribute_query.condition_operator == :match
+
+      # in the case that the attribute is actually a query object, determine the query type
+      op = case attribute_query.condition_operator # (i.e :gt, :lt, :like, :eql)
+        when :eql     then "= ?"
+        when :lt      then "< ?"
+        when :lte     then "<= ?"
+        when :gt      then "> ?"
+        when :gte     then ">= ?"
+        when :like    then "LIKE ?"
+        when :in      then "IN (?)"
+        when :not     then "NOT IN (?)"
+        when :regexp  then "REGEXP ?"
+      end
+      "#{column} #{op}"
+    end
+
+    # similar Model.all which is an alias for Model.find(:all), except concatenates conditions with "OR" instead of "AND"
+    # Model.any(:conditions => { :name.like => "%Na%", :age.gt > 30 }) # => `name` LIKE "%Na" OR `age` > 30
+    def any(*args)
+      options = args.extract_options! # extract the options off the end
+      options[:conditions][:connect] = ' OR ' if options[:conditions] # set the condition_join condition
+      args << options # add options back on the end
+      find(:all, *args)
+    end
+
+    def view_statement(title, expression)
+      puts "--------->#{title}<----------"
+      puts expression.kind_of?(String) ? "==== #{expression} ======"  : "==== #{expression.inspect} ======"
+      puts "\n"
+      expression
+    end
+  end
+
+  # define symbol methods for each possible condition qualifier
+  module SymbolQueryExtensions
+    [ :eql, :lt, :gt, :gte, :lte, :in, :like, :not, :match, :regexp ].each do |query_operator|
+      define_method(query_operator) do
+        AttributeCondition.new(self, query_operator)
+      end
+    end
+  end
+
+  # An attribute condition simply contains an attribute name as well as a condition operator
+  class AttributeCondition
+    # attr_name : String => the attribute that will be used in the condition (i.e :name, :age, ...)
+    # operator  : Symbol => the operator which will be used for comparison (i.e :gt, :lt, :like, :eql, ...)
+    attr_accessor :attribute_name, :condition_operator
+
+    def initialize(attribute_name, condition_operator)
+      @attribute_name, @condition_operator = attribute_name, condition_operator
+    end
+
+    # returns just the attribute name for simplicity
+    def to_s
+      @attribute_name.to_s
+    end
+
+    # returns the attribute name as a symbol
+    def to_sym
+      @attribute_name.to_sym
+    end
+
+    # redefines comparison for attribute condition objects if the attribute name and operator are the same
+    def <=>(other)
+      [self.condition_operator.to_s, self.attribute_name.to_s] <=> [other.condition_operator.to_s, other.attribute_name.to_s]
+    end
+
+    # redefines equality within the ruby objects based on the new comparison operator
+    def ==(other)
+      (self <=> other) == 0
+    end
+
+    def eql?(other)
+      self.hash == other.hash
+    end
+
+    def hash
+      ["AttributeCondition", self.condition_operator.to_s, self.attribute_name.to_s].hash
+    end
+  end
+end

data/test/conditions_fu_test.rb

@@ -0,0 +1,151 @@
+require File.dirname(__FILE__) + "/test_helper.rb"
+require File.dirname(__FILE__) + "/../init.rb"
+
+class Person < ActiveRecord::Base
+
+end
+
+class ConditionsFuTest < Test::Unit::TestCase
+  load_all_fixtures
+
+  def setup
+    @nathan  =  Person.find(1)
+    @bob     =  Person.find(2)
+    @joan    =  Person.find(3)
+    @tom     =  Person.find(4)
+    @nathan2 =  Person.find(5)
+  end
+
+  # conditions_fu attribute condition tests
+
+  def test_two_attribute_conditions_with_same_attribute_and_operator_are_equal
+    # tests that two attribute conditions that have the same operator are equal
+    condition_a = :first_name.eql
+    condition_b = :first_name.eql
+    assert_equal condition_a, condition_b
+  end
+
+  def test_two_attribute_conditions_with_same_attribute_and_different_operator_are_not_equal
+    # tests that two attribute conditions that have a different operator are not equal
+    condition_a = :first_name.eql
+    condition_b = :first_name.in
+    assert_not_equal condition_a, condition_b
+  end
+
+  def test_two_attribute_conditions_with_different_attribute_and_same_operator_are_not_equal
+    # tests that two attribute conditions that have a different operator are not equal
+    condition_a = :first_name.eql
+    condition_b = :last_name.eql
+    assert_not_equal condition_a, condition_b
+  end
+
+  def test_two_attribute_conditions_with_same_attribute_and_operator_are_equal_in_hash
+    condition_hash_a = { :conditions => { :first_name.eql => "matt" } }
+    condition_hash_b = { :conditions => { :first_name.eql => "matt" } }
+    assert_equal condition_hash_a, condition_hash_b
+  end
+  
+  def test_two_attribute_conditions_with_same_attribute_and_different_operator_are_not_equal_in_hash
+    condition_hash_a = { :conditions => { :first_name.eql => "matt" } }
+    condition_hash_b = { :conditions => { :first_name.like => "matt" } }
+    assert_not_equal condition_hash_a, condition_hash_b
+  end
+
+  # conditions_fu plugin tests
+
+  def test_equal_operator_should_work
+    assert_equal [@bob], Person.all(:conditions => { :first_name.eql => "Bob" })
+    assert_equal @bob, Person.first(:conditions => { :first_name.eql => "Bob" })
+    assert_equal [@nathan, @tom], Person.all(:conditions => { :occupation.eql => "Student" })
+    assert_equal [@bob, @tom],  Person.all(:conditions => { :favorite_number.eql => 34 })
+    assert_equal [@nathan],  Person.all(:conditions => { :first_name.eql => "Nathan", :last_name.eql => "Esquenazi" })
+    assert_equal @nathan,  Person.first(:conditions => { :first_name.eql => "Nathan", :last_name.eql => "Esquenazi" })
+    assert_equal [@nathan, @bob, @nathan2], Person.any(:conditions => { :last_name.eql => "Villa", :first_name.eql => "Nathan" })
+  end
+
+  def test_like_should_work
+    assert_equal [@nathan], Person.all(:conditions => { :first_name.like => "Na%", :last_name.like => "%squ%" })
+    assert_equal [@nathan, @nathan2], Person.all(:conditions => { :first_name.like => "Nathan" })
+    assert_equal @nathan, Person.first(:conditions => { :first_name.like => "Nathan" })
+    assert_equal [@nathan, @nathan2], Person.all(:conditions => { :first_name.like => "Nat%" })
+    assert_equal [@nathan, @bob, @joan, @tom], Person.all(:conditions => { :occupation.like => "%t%" })
+    assert_equal [], Person.all(:conditions => { :first_name.like => "Nat" })
+    assert_equal [@nathan, @bob, @nathan2], Person.any(:conditions => { :last_name.like => "%Vil%", :first_name.like => "%Nat%" })
+  end
+
+  def test_less_than_should_work
+    assert_equal [@nathan], Person.all(:conditions => { :age.lt => 23 })
+    assert_equal [@nathan, @tom], Person.all(:conditions => { :age.lt => 30 })
+    assert_equal [@joan], Person.all(:conditions => { :favorite_number.lt => 25 })
+    assert_equal @joan, Person.first(:conditions => { :favorite_number.lt => 25 })
+    assert_equal [@nathan, @joan], Person.any(:conditions => { :age.lt => 22, :age.gte => 56 })
+  end
+
+  def test_less_equal_than_should_work
+    assert_equal [@nathan], Person.all(:conditions => { :age.lte => 23 })
+    assert_equal [@nathan, @tom], Person.all(:conditions => { :age.lte => 30 })
+    assert_equal [@joan], Person.all(:conditions => { :favorite_number.lte => 25 })
+    assert_equal @joan, Person.first(:conditions => { :favorite_number.lte => 25 })
+    assert_equal [@nathan], Person.all(:conditions => { :age.lte => 21, :first_name => "Nathan" })
+    assert_equal [@nathan, @joan], Person.any(:conditions => { :age.lte => 21, :age.gte => 56 })
+  end
+
+  def test_greater_than_should_work
+    assert_equal [@joan, @nathan2], Person.all(:conditions => { :age.gt => 50 })
+    assert_equal [@bob], Person.all(:conditions => { :age.gt => 30, :age.lt => 40 })
+    assert_equal @bob, Person.first(:conditions => { :age.gt => 30, :age.lt => 40 })
+    assert_equal [@nathan2], Person.all(:conditions => { :favorite_number.gt => 500})
+  end
+
+  def test_greater_equal_than_should_work
+    assert_equal [@joan, @nathan2], Person.all(:conditions => { :age.gte => 50 })
+    assert_equal [@bob], Person.all(:conditions => { :age.gte => 30, :age.lt => 40 })
+    assert_equal [@nathan2], Person.all(:conditions => { :favorite_number.gte => 500})
+    assert_equal [@joan, @nathan2], Person.all(:conditions => { :age.gte => 54 })
+    assert_equal [@nathan], Person.all(:conditions => { :age.gte => 21, :age.lte => 21 })
+  end
+
+  def test_in_should_work
+    assert_equal [@nathan, @joan, @nathan2], Person.all(:conditions => { :first_name.in => ["Nathan", "Joan"] })
+    assert_equal [@bob, @joan, @tom], Person.all(:conditions => { :favorite_number.in => [34, 23] })
+    assert_equal [@nathan, @tom], Person.all(:conditions => { :occupation.in => ["Student"] })
+    assert_equal @nathan, Person.first(:conditions => { :occupation.in => ["Student"] })
+    assert_equal [@nathan, @bob, @tom], Person.any(:conditions => { :occupation.in => ["Student"], :age.in => [38] })
+  end
+
+  def test_not_in_should_work
+    assert_equal [@nathan, @nathan2], Person.all(:conditions => { :first_name.not => ["Tom", "Joan", "Bob"] })
+    assert_equal [@bob, @tom], Person.all(:conditions => { :age.not => [21, 56, 54] })
+    assert_equal @bob, Person.first(:conditions => { :age.not => [21, 56, 54] })
+    assert_equal [@bob, @joan, @tom, @nathan2], Person.any(:conditions => { :age.not => [21, 56, 54], :age.not => [21] })
+  end
+
+  # regression tests (make sure the plugin doesn't destroy the existing find options)
+
+  def test_simple_expectations
+    # Sanity Check
+    assert_equal 5, Person.all.size
+    assert_equal "Esquenazi", Person.find(1).last_name
+    assert_equal "Tom", Person.find(4).first_name
+  end
+
+  def test_old_string_queries_work
+    # test that the old activerecord queries still work
+    assert_equal [@nathan, @nathan2], Person.all(:conditions => { :first_name => "Nathan" })
+    assert_equal @nathan, Person.first(:conditions => { :first_name => "Nathan" })
+    assert_equal [@nathan, @nathan2], Person.find(:all, :conditions => { :first_name => "Nathan" })
+    assert_equal [@nathan], Person.find(:all, :conditions => { :first_name => "Nathan", :last_name => "Esquenazi" })
+    assert_equal @nathan, Person.find(:first, :conditions => { :first_name => "Nathan", :last_name => "Esquenazi" })
+    assert_equal [@bob], Person.find(:all, :conditions => { :occupation => "Contractor", :first_name => "Bob" })
+  end
+
+  def test_old_range_queries_work
+    assert_equal [@bob], Person.all(:conditions => { :age => 37..39 })
+    assert_equal [@bob, @tom], Person.all(:conditions => { :favorite_number => 33..35 })
+  end
+
+  def test_old_array_queries_work
+    assert_equal [@nathan, @bob, @tom, @nathan2], Person.all(:conditions => { :first_name => ['Nathan', 'Bob', 'Tom'] })
+    assert_equal [@bob, @tom], Person.all(:conditions => { :age => [24, 38] })
+  end
+end

data/test/database.yml

@@ -0,0 +1,18 @@
+sqlite3_file:
+  adapter: sqlite3
+  dbfile: conditions_fu.sqlite.db
+sqlite3:
+  adapter: sqlite3
+  database: ":memory:"
+postgresql:
+  adapter: postgresql
+  username: postgres
+  password: postgres
+  database: conditions_fu_test
+  min_messages: ERROR
+mysql:
+  adapter: mysql
+  host: localhost
+  username: conditions_fu
+  password: conditions_fu
+  database: conditions_fu_test

data/test/fixtures/people.yml

@@ -0,0 +1,61 @@
+# == Schema Information
+# Schema version: 20080605094825
+#
+# Table name: people
+#
+#  id              :integer         not null, primary key
+#  first_name      :string(255)
+#  last_name       :string(255)
+#  occupation      :string(255)
+#  age             :integer
+#  phone           :integer
+#  favorite_number :integer
+#  created_at      :datetime
+#  updated_at      :datetime
+#
+
+nathan:
+  id: 1
+  first_name: Nathan
+  last_name: "Esquenazi"
+  occupation: "Student"
+  age: 21
+  phone: 6267685768
+  favorite_number: 121
+
+bob:
+  id: 2
+  first_name: "Bob"
+  last_name: "Villa"
+  occupation: "Contractor"
+  age: 38
+  phone: 123456787
+  favorite_number: 34
+
+joan:
+  id: 3
+  first_name: "Joan"
+  last_name: "Taylor"
+  occupation: "Doctor"
+  age: 56
+  phone: 876876895
+  favorite_number: 23
+
+tom:
+  id: 4
+  first_name: "Tom"
+  last_name:  "Fields"
+  occupation: "Student"
+  age: 24
+  phone: 2134324634
+  favorite_number: 34
+
+nathan2:
+  id: 5
+  first_name: "Nathan"
+  last_name:  "Goldberg"
+  occupation: "Lawyer"
+  age: 54
+  phone: 2453545435
+  favorite_number: 1000
+  

data/test/schema.rb

@@ -0,0 +1,8 @@
+ActiveRecord::Schema.define(:version => 1) do
+	
+	create_table :people do |t|
+    t.string :first_name, :last_name, :occupation
+    t.integer :age, :phone, :favorite_number
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,39 @@
+require 'test/unit'
+require 'rubygems'
+require 'active_record'
+require 'active_record/fixtures'
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+RAILS_DEFAULT_LOGGER = ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite3'])
+
+load(File.dirname(__FILE__) + "/schema.rb") if File.exist?(File.dirname(__FILE__) + "/schema.rb")
+
+Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+$LOAD_PATH.unshift(Test::Unit::TestCase.fixture_path)
+
+class Test::Unit::TestCase #:nodoc:
+  def create_fixtures(*table_names)
+    if block_given?
+      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names) { yield }
+    else
+      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names)
+    end
+  end
+  
+	def self.load_all_fixtures
+		all_fixtures = Dir.glob("#{File.dirname(__FILE__)}/fixtures/*.yml").collect do |f|
+			puts "Loading fixture '#{f}'"
+			File.basename(f).gsub(/\.yml$/, "").to_sym
+		end
+		Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, all_fixtures)
+	end
+
+  # Turn off transactional fixtures if you're working with MyISAM tables in MySQL
+  self.use_transactional_fixtures = true
+  
+  # Instantiated fixtures are slow, but give you @david where you otherwise would need people(:david)
+  self.use_instantiated_fixtures  = false
+
+  # Add more helper methods to be used by all tests here...
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: sprsquish-conditions_fu
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Nathan Esquenazi
+- Jeff Smick
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-29 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: README
+email: sprsquish@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- TODO.txt
+- VERSION.yml
+- lib/conditions_fu.rb
+- test/conditions_fu_test.rb
+- test/database.yml
+- test/fixtures
+- test/fixtures/people.yml
+- test/schema.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/sprsquish/conditions_fu
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: README
+test_files: []
+