brendan-entrails 1.0.1

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2008-06-20
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,21 @@
+bin
+bin/entrails
+entrails.gemspec
+History.txt
+init.rb
+lib
+lib/entrails
+lib/entrails/active_record
+lib/entrails/active_record/better_conditions.rb
+lib/entrails/active_record/find_by_association.rb
+lib/entrails/active_record.rb
+lib/entrails.rb
+Manifest.txt
+Rakefile
+README.txt
+spec
+spec/entrails
+spec/entrails/active_record
+spec/entrails/active_record/better_conditions_spec.rb
+spec/entrails/active_record/find_by_association_spec.rb
+spec/spec_helper.rb

data/README.txt

@@ -0,0 +1,54 @@
+= entrails =
+
+* http://github.com/brendan/entrails
+
+== DESCRIPTION:
+
+This is a collection of extensions to Rails internals that I've found to be absolutely indispensible
+since I implimented them.
+
+The real action is happening in the following two files at the moment:
+http://github.com/brendan/entrails/tree/master/lib/entrails/active_record/better_conditions.rb
+http://github.com/brendan/entrails/tree/master/lib/entrails/active_record/find_by_association.rb= entrails
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* sudo gem install brendan-entrails -s http://gems.github.com
+* require 'entrails' in your rails app
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Brendan Baldwin
+
+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/Rakefile

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
+require 'rubygems'
+require './lib/entrails.rb'
+require 'rake'
+require 'spec/rake/spectask'
+
+desc "Generates the gemspec, Manifest.txt and builds the gem."
+task :gem => ["gem:gemspec","gem:manifest"]
+
+namespace :gem do
+  desc "Generates the entrails.gemspec file"
+  task :gemspec do
+    gemspec_code = <<-gemspec
+      Gem::Specification.new do |s|
+        s.name = %q{entrails}
+        s.version = #{Entrails::VERSION.inspect}
+
+        s.specification_version = 2 if s.respond_to? :specification_version=
+
+        s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+        s.authors = #{Entrails::AUTHORS.inspect}
+        s.date = #{Time.now.strftime('%Y-%m-%d').inspect}
+        s.default_executable = %q{entrails}
+        s.description = #{Entrails::DESCRIPTION.inspect}
+        s.email = #{Entrails::EMAIL.inspect}
+        s.executables = ["entrails"]
+        s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
+        s.files = #{Entrails::MANIFEST.inspect}
+        s.has_rdoc = true
+        s.homepage = #{Entrails::HOMEPAGE.inspect}
+        s.rdoc_options = ["--main", "README.txt"]
+        s.require_paths = ["lib"]
+        s.rubygems_version = %q{1.1.1}
+        s.summary = #{Entrails::DESCRIPTION.inspect}
+      end
+    gemspec
+    gemspec = File.open(File.join(File.dirname(__FILE__),'entrails.gemspec'),'w')
+    gemspec.write(gemspec_code)
+    gemspec.close
+  end
+  desc "Generates the Manifest.txt file"
+  task :manifest do
+    manifest = File.open(File.join(File.dirname(__FILE__),'Manifest.txt'),'w')
+    manifest.write(Entrails::MANIFEST.join("\n")<<"\n")
+    manifest.close
+  end
+end
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+namespace :spec do
+  desc "Run all specs and stake out all files/folders for changes, running rake spec upon change"
+  task :auto => 'spec' do
+
+    # This task assumes you are running on a Mac, with growl installed.  Perhaps
+    # there will be a better way to abstract this, but it works for us now.
+    def growl(title, msg, img, pri=0, sticky="")
+      system "growlnotify -n autotest --image ~/.autotest_images/#{img} -p #{pri} -m #{msg.inspect} #{title} #{sticky}"
+    end
+    def self.growl_fail(output)
+      growl "FAIL", "#{output}", "fail.png", 2
+    end
+    def self.growl_pass(output)
+      growl "Pass", "#{output}", "pass.png"
+    end
+
+    command = 'rake spec'
+    files = {}
+
+    def files.reglob
+      Dir['**/*.rb'].each {|file| self[file] ||= File.mtime(file)}
+    end
+
+    files.reglob
+
+    puts "Watching #{files.keys.join(', ')}\n\nFiles: #{files.keys.length}"
+
+    trap('INT') do
+      puts "\nQuitting..."
+      exit
+    end
+
+    loop do
+
+      sleep 3
+
+      files.reglob
+
+      changed_file, last_changed = files.find do |file, last_changed|
+        begin
+          File.mtime(file) > last_changed
+        rescue
+          files.delete(file)
+        end
+      end
+
+      if changed_file
+        files[changed_file] = File.mtime(changed_file)
+        puts "=> #{changed_file} changed, running #{command}"
+        results = `#{command}`
+        puts results
+
+        if results.include? 'tests'
+          output = results.slice(/(\d+)\s+tests?,\s*(\d+)\s+assertions?,\s*(\d+)\s+failures?(,\s*(\d+)\s+errors)?/)
+          if output
+            $~[3].to_i + $~[5].to_i > 0 ? growl_fail(output) : growl_pass(output)
+          end
+        else
+          output = results.slice(/(\d+)\s+examples?,\s*(\d+)\s+failures?(,\s*(\d+)\s+not implemented)?/)
+          if output
+            $~[2].to_i > 0 ? growl_fail(output) : growl_pass(output)
+          end
+        end
+        # TODO Generic growl notification for other actions
+
+        puts "=> done"
+      end
+
+    end
+     
+  end
+end

data/entrails.gemspec

@@ -0,0 +1,22 @@
+      Gem::Specification.new do |s|
+        s.name = %q{entrails}
+        s.version = "1.0.1"
+
+        s.specification_version = 2 if s.respond_to? :specification_version=
+
+        s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+        s.authors = ["Brendan Baldwin"]
+        s.date = "2008-06-20"
+        s.default_executable = %q{entrails}
+        s.description = "This is a collection of extensions to Rails internals that I've found to be absolutely indispensible since I implimented them.  The real action is happening in the following two files at the moment: http://github.com/brendan/entrails/tree/master/lib/entrails/active_record/better_conditions.rb http://github.com/brendan/entrails/tree/master/lib/entrails/active_record/find_by_association.rb"
+        s.email = ["brendan@usergenic.com"]
+        s.executables = ["entrails"]
+        s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
+        s.files = ["bin", "bin/entrails", "entrails.gemspec", "History.txt", "init.rb", "lib", "lib/entrails", "lib/entrails/active_record", "lib/entrails/active_record/better_conditions.rb", "lib/entrails/active_record/find_by_association.rb", "lib/entrails/active_record.rb", "lib/entrails.rb", "Manifest.txt", "Rakefile", "README.txt", "spec", "spec/entrails", "spec/entrails/active_record", "spec/entrails/active_record/better_conditions_spec.rb", "spec/entrails/active_record/find_by_association_spec.rb", "spec/spec_helper.rb"]
+        s.has_rdoc = true
+        s.homepage = "http://github.com/brendan/entrails"
+        s.rdoc_options = ["--main", "README.txt"]
+        s.require_paths = ["lib"]
+        s.rubygems_version = %q{1.1.1}
+        s.summary = "This is a collection of extensions to Rails internals that I've found to be absolutely indispensible since I implimented them.  The real action is happening in the following two files at the moment: http://github.com/brendan/entrails/tree/master/lib/entrails/active_record/better_conditions.rb http://github.com/brendan/entrails/tree/master/lib/entrails/active_record/find_by_association.rb"
+      end

data/init.rb

@@ -0,0 +1,2 @@
+require 'entrails'
+Entrails.apply

data/lib/entrails.rb

@@ -0,0 +1,17 @@
+module Entrails
+  VERSION='1.0.1'
+  AUTHORS=["Brendan Baldwin"]
+  EMAIL=["brendan@usergenic.com"]
+  DESCRIPTION=%q{This is a collection of extensions to Rails internals that I've found to be absolutely indispensible since I implimented them.  The real action is happening in the following two files at the moment: http://github.com/brendan/entrails/tree/master/lib/entrails/active_record/better_conditions.rb http://github.com/brendan/entrails/tree/master/lib/entrails/active_record/find_by_association.rb}
+  FOLDER=File.expand_path(File.join(File.dirname(__FILE__),'..'))
+  MANIFEST=Dir.glob(File.join(FOLDER,'**','*')).map{|path|path[FOLDER.size+1..-1]}
+  HOMEPAGE="http://github.com/brendan/entrails"
+  class << self
+    def apply
+      ::ActiveRecord::Base.extend ::Entrails::ActiveRecord::BetterConditions
+      ::ActiveRecord::Base.extend ::Entrails::ActiveRecord::FindByAssociation
+    end
+  end
+end
+
+require 'entrails/active_record'

data/lib/entrails/active_record.rb

@@ -0,0 +1,5 @@
+module Entrails::ActiveRecord
+end
+
+require 'entrails/active_record/better_conditions'
+require 'entrails/active_record/find_by_association'

data/lib/entrails/active_record/better_conditions.rb

@@ -0,0 +1,48 @@
+module Entrails::ActiveRecord::BetterConditions
+  
+  protected
+  
+  # Allows arrays to represent logical symbolic expressions by use of the
+  # symbols :and, :or, and :not and the embedding of nested array and hash
+  # conditions.
+  def sanitize_sql_array_with_better_conditions(array)
+    conditions = []
+    joiner = 'OR'
+    negate = false
+    index = 0
+    array.each_with_index do |element, index|
+      case element
+      when :and, 'and' : joiner = 'AND'
+      when :or,  'or'  : joiner = 'OR'
+      when :not, 'not' : negate = !negate
+      else
+        # following matches pattern for ActiveRecord's built-in array support
+        return sanitize_sql_array_without_better_conditions(array) if index == 0 and element.is_a?(String)
+        conditions << sanitize_sql(element)
+      end
+    end
+    return if conditions.empty?
+    sql = (conditions.size==1) ? conditions.first : "(#{conditions.join(") #{joiner} (")})"
+    sql = "NOT (#{sql})" if negate
+    sql
+  end
+
+  # Allows true or false to be used as a convenience to short-circuit conditional
+  # branches.  
+  def sanitize_sql_with_better_conditions(object)
+    case object
+    when true  : '1=1'
+    when false : '1=0'
+    else sanitize_sql_without_better_conditions(object)
+    end
+  end
+
+  def self.extended(host)
+    super
+    class << host
+      alias_method_chain :sanitize_sql, :better_conditions
+      alias_method_chain :sanitize_sql_array, :better_conditions
+    end
+  end
+  
+end

data/lib/entrails/active_record/find_by_association.rb

@@ -0,0 +1,257 @@
+module Entrails::ActiveRecord::FindByAssociation
+  
+  protected
+  
+  # Sanitizes a hash of association/value pairs into SQL conditions,
+  # passing on attributes that are not associations back down into
+  # the original sanitize_sql_hash method.
+  def sanitize_sql_hash_with_find_by_association(attrs)
+    attrs = attrs.dup
+    association_conditions = attrs.map do |attr, value|
+      # Lets process Attributes that are names of Associations
+      if association = reflect_on_association(attr.to_sym)
+        attrs.delete attr
+        if association.options[:polymorphic]
+          foreign_type_attribute = (association.options[:foreign_type]||"#{association.name}_type").to_s
+          polymorphic_type = attrs[foreign_type_attribute.to_sym]
+          raise "Polymorphic belongs_to associations must be qualified by the inclusion of a reference to the foreign_type attribute in the conditions hash.  Missing #{foreign_type_attribute} key or value in conditions hash passed to sanitize_sql_hash_with_find_by_association for association #{association.name}." unless polymorphic_type
+          association_class = polymorphic_type.constantize
+        else
+          association_class = association.klass
+        end
+        construct_find_by_association_conditions_sql(association, value, :type => association_class)
+      end
+    end.compact.join(' AND ')
+    non_association_conditions = attrs.empty? ? '' : sanitize_sql_hash_without_find_by_association(attrs)
+  
+    # Non Association Conditions are cheaper to calculate so we optimize the query plan by issuing them first
+    [ non_association_conditions, association_conditions ].reject{|conditions| conditions.blank?}.join(' AND ')
+  end
+
+  # Prevent infinite recursion when assigning scopes via with_scope block
+  # by sanitizing non-string scope conditions.
+  def with_scope_with_find_by_association(options={}, action = :merge, &block)
+    if options[:find] and options[:find][:conditions] and !options[:find][:conditions].is_a?(String)
+      options = options.dup
+      options[:find] = options[:find].dup
+      options[:find][:conditions] = sanitize_sql(options[:find][:conditions])
+    end
+    with_scope_without_find_by_association options, action, &block
+  end
+
+  private
+  
+  def construct_find_by_association_conditions_sql(association, conditions, options={})
+    
+    association_type = options[:type]
+    association = reflect_on_association(association) unless association.is_a?(ActiveRecord::Reflection::AssociationReflection)
+
+    association.options[:polymorphic] and !association_type and
+      raise "FindByAssociation requires a :type option for generation of polymorphic belongs_to association subqueries."  
+    
+    association_type ||= association.is_a?(String) ? association_type.constantize : association.klass
+
+    # If a nil is present in the association conditions we have to handle as a special case due to the way
+    # sql handles NULL values in sets vs. empty sets.
+    nil_condition =
+      case conditions
+      when Array : !!conditions.compact! # compacts the array and returns true/false if it changed
+      when NilClass : true
+      else false
+      end
+
+    segments = []
+
+    # To handle has_many :through, lets process the through_reflection and then send over the conditions...
+    conditions.blank? or segments <<
+      if association.options[:through]
+        through_association = reflect_on_association(association.through_reflection.name)
+        source_association ||= through_association.klass.reflect_on_association(association.options[:source])
+        source_association ||= through_association.klass.reflect_on_association(association.name)
+        source_association ||= through_association.klass.reflect_on_association(association.name.to_s.singularize.to_sym)
+
+        raise "Unknown source_association for HasManyThroughAssociation #{self}##{association.name}." unless source_association
+
+        source_subquery_sql = through_association.klass.__send__(:construct_find_by_association_conditions_subquery_sql,
+          source_association, conditions, :type => association_type)
+
+        through_subquery_sql = construct_find_by_association_conditions_subquery_sql(
+          through_association, source_subquery_sql, :type => through_association.klass)
+      else
+        construct_find_by_association_conditions_subquery_sql(association, conditions, :type => association_type)
+      end
+
+    nil_condition and segments << construct_find_by_association_conditions_nil_condition_sql(association)
+
+    segments.join(' OR ') unless segments.empty?
+  
+  end
+  
+  def construct_find_by_association_conditions_nil_condition_sql(association)
+    nil_subquery_sql = 
+      if association.options[:through]
+        through_association = reflect_on_association(association.through_reflection.name)
+        through_association.klass.__send__(:construct_finder_sql, options_for_find_by_association_conditions_subquery(through_association, nil))
+      else
+        association.klass.__send__(:construct_finder_sql, options_for_find_by_association_conditions_subquery(association, nil, :type => association.klass))
+      end
+
+    nil_subquery_sql = "SELECT _id FROM (#{nil_subquery_sql}) _tmp" if use_derived_table_hack_for_subquery_optimization?
+
+    case association.macro
+    when :belongs_to : "#{table_name}.#{connection.quote_column_name(association.primary_key_name)} NOT IN " <<
+                       "(#{nil_subquery_sql}) OR #{table_name}.#{connection.quote_column_name(association.primary_key_name)} IS NULL"
+    when :has_one    : "#{table_name}.#{connection.quote_column_name(primary_key)} NOT IN (#{nil_subquery_sql})"
+    when :has_many   : "#{table_name}.#{connection.quote_column_name(primary_key)} NOT IN (#{nil_subquery_sql})"
+    when :has_and_belongs_to_many : "#{table_name}.#{connection.quote_column_name(primary_key)} NOT IN " <<
+                                    "(SELECT #{connection.quote_column_name(association.primary_key_name)} " <<
+                                    "FROM #{association.options[:join_table]} WHERE " <<
+                                    "#{connection.quote_column_name(association.association_foreign_key)} IN " <<
+                                    "(#{nil_subquery_sql}))"
+    else raise "FindByAssociation does not recognize the '#{association.macro}' association macro."
+    end
+    
+  end
+
+  def construct_find_by_association_conditions_subquery_sql(association, conditions, options={})
+
+    association_type, through_type = options[:type], options[:through_type]
+    association = reflect_on_association(association) unless association.is_a?(ActiveRecord::Reflection::AssociationReflection)
+    
+    association.options[:polymorphic] and !association_type and
+      raise "FindByAssociation requires a :type option for generation of polymorphic belongs_to association subqueries."
+    
+    association_type ||= association_type.is_a?(String) ? association_type.constantize : association.klass
+
+    conditions =
+      case
+      when (conditions == []) : nil
+      when (conditions.class.is_a?(Entrails::ActiveRecord::FindByAssociation)) : [conditions]
+      else conditions
+      end
+      
+    if conditions.is_a?(Array) and conditions.all?{|c|c.class.is_a?(Entrails::ActiveRecord::FindByAssociation)}
+      ids = conditions.map{|c| c.attributes[association_type.primary_key] }
+      ids = ids.first unless ids.size > 1
+      conditions = { association_type.primary_key => ids }
+    end
+
+    if conditions and subquery_sql = association_type.__send__(:construct_finder_sql, 
+      options_for_find_by_association_conditions_subquery(association, conditions, :type => association_type, :through_type => through_type))
+
+      subquery_sql &&= "SELECT _id FROM (#{subquery_sql}) _tmp" if use_derived_table_hack_for_subquery_optimization?
+
+      case association.macro
+      when :belongs_to : "#{table_name}.#{connection.quote_column_name(association.primary_key_name)} IN (#{subquery_sql})"
+      when :has_and_belongs_to_many : "#{table_name}.#{connection.quote_column_name(primary_key)} IN " <<
+                                      "(SELECT #{connection.quote_column_name(association.primary_key_name)} " <<
+                                      "FROM #{association.options[:join_table]} WHERE " <<
+                                      "#{connection.quote_column_name(association.association_foreign_key)} IN " <<
+                                      "(#{subquery_sql}))"
+      when :has_one  : "#{table_name}.#{connection.quote_column_name(primary_key)} IN (#{subquery_sql})"
+      when :has_many : "#{table_name}.#{connection.quote_column_name(primary_key)} IN (#{subquery_sql})"
+      else raise "Unrecognized Association Macro '#{association.macro}' not supported by FindByAssociation."
+      end
+
+    end
+  end
+  
+  # Update the dynamic finders to allow referencing association names instead of
+  # just column names.
+  def method_missing_with_find_by_association(method_id, *arguments)
+    match = /^find_(all_by|by)_([_a-zA-Z]\w*)$/.match(method_id.to_s)
+    match = /^find_or_(initialize|create)_by_([_a-zA-Z]\w*)$/.match(method_id.to_s) unless match
+    if match
+      action_type = ($1 =~ /by/) ? :finder : :instantiator
+      attribute_names = extract_attribute_names_from_match(match)
+      options_argument = (arguments.size > attribute_names.size) ? arguments.last : {}
+      associations = {}
+      index = 0
+
+      non_associations = attribute_names.select do |attribute_name|
+        attribute_chain = attribute_name.split('_having_')
+        attribute_name = attribute_chain.shift
+        if reflect_on_association(attribute_name.to_sym)
+          associations[attribute_name.to_sym] ||= attribute_chain.reverse.inject(arguments.delete_at(index)){|v,n|{n=>v}}
+          false
+        else
+          index += 1
+          true
+        end
+      end
+
+      unless associations.empty?
+        find_options = { :conditions => associations }
+        set_readonly_option!(find_options)
+        with_scope :find => find_options do
+          if action_type == :finder
+            finder = determine_finder(match)
+            return __send__(finder, options_argument) if non_associations.empty?
+            return __send__("find#{'_all' if finder == :find_every}_by_#{non_associations.join('_and_')}".to_sym, *arguments)
+          else
+            instantiator = determine_instantiator(match)
+            return find_initial(options_argument) || __send__(instantiator, associations) if non_associations.empty?
+            return __send__("find_or_#{instantiator}_by_#{non_associations.join('_and_')}".to_sym, *arguments) 
+          end
+        end
+      end
+    end
+
+    method_missing_without_find_by_association method_id, *arguments
+
+  end
+
+  def options_for_find_by_association_conditions_subquery(association, conditions, options={})
+
+    association_type, through_type = options[:type], options[:through_type]
+    association = reflect_on_association(association) unless association.is_a? ActiveRecord::Reflection::AssociationReflection
+    
+    association.options[:polymorphic] and !association_type and
+      raise "Polymorphic belongs_to associations require the :type argument for options_for_find_by_association_conditions_subquery."
+
+    association_type ||= association_type.is_a?(String) ? association_type.constantize : association.klass
+
+    options = {}
+    
+    key_column = case association.macro
+                 when :belongs_to,
+                      :has_and_belongs_to_many : association_type.primary_key
+                 else association.primary_key_name
+                 end
+
+    options[:select] = "#{key_column} _id"
+    segments = []
+    segments << "#{key_column} IS NOT NULL"
+    conditions and segments << association_type.__send__(:sanitize_sql, conditions)
+    association.options[:conditions] and segments << association_type.__send__(:sanitize_sql, association.options[:conditions])
+    association.options[:as] and segments << association_type.__send__(:sanitize_sql, (association_type.reflect_on_association(association.options[:as].to_sym).options[:foreign_type] || :"#{association.options[:as]}_type").to_sym => (through_type||self).name)
+    segments.reject! {|c|c.blank?}
+    options[:conditions] = segments.size > 1 ? "(#{segments.join(') AND (')})" : segments.first unless segments.empty?
+
+    # subqueries in MySQL can not use order or limit
+    # options[:order] = association.options[:order] if association.options[:order]
+    # options[:limit] = association.options[:limit] if association.options[:limit]
+
+    options
+
+  end
+  
+  # This is an affordance to turn on/off the use of a wrapper query that generates
+  # an aliased derived table for the purpose of query-plan optimization for some
+  # database engines.  This hack has been shown to significantly benefit query times
+  # for mysql and sqlite3. (has not yet been tested with other engines.)
+  def use_derived_table_hack_for_subquery_optimization?
+    true
+  end
+  
+  def self.extended(host)
+    super
+    class << host
+      alias_method :sanitize_sql_hash_for_conditions, :sanitize_sql_hash_with_find_by_association
+      alias_method_chain :method_missing, :find_by_association
+      alias_method_chain :sanitize_sql_hash, :find_by_association
+      alias_method_chain :with_scope, :find_by_association
+    end
+  end
+  
+end

data/spec/entrails/active_record/better_conditions_spec.rb

@@ -0,0 +1,48 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Entrails::ActiveRecord::BetterConditions do
+  def base
+    @base ||= Class.new do
+      stub!(:sanitize_sql).and_return('sql')
+      stub!(:sanitize_sql_array).and_return('sql')
+      extend Entrails::ActiveRecord::BetterConditions
+    end
+  end
+  describe '#sanitize_sql_array_with_better_conditions' do
+    it "returns sql representing the intersection of sub-expressions when array contains the logical :and prefix" do
+      base.class_eval{ sanitize_sql_array_with_better_conditions([:and, 'exp1', 'exp2']) }.should == '(sql) AND (sql)'
+    end
+    it "returns sql representing the union of sub-expressions when array contains the logical :or prefix" do
+      base.class_eval{ sanitize_sql_array_with_better_conditions([:or, 'exp1', 'exp2']) }.should == '(sql) OR (sql)'
+    end
+    it "returns sql representing the negation of sub-expressions when array contains the logical :not prefix" do
+      base.class_eval{ sanitize_sql_array_with_better_conditions([:not, 'exp']) }.should == 'NOT (sql)'
+    end
+    it "returns sql representing the negation of the intersection of sub-expressions when array contains the logical :not and :and prefix" do
+      base.class_eval{ sanitize_sql_array_with_better_conditions([:not, :and, 'exp1', 'exp2']) }.should == 'NOT ((sql) AND (sql))'
+    end
+    it "returns sql representing the negation of the union of sub-expressions when array contains the logical :not and :or prefix" do
+      base.class_eval{ sanitize_sql_array_with_better_conditions([:not, :or, 'exp1', 'exp2']) }.should == 'NOT ((sql) OR (sql))'
+    end
+    it "will delegate to sanitize_sql_array_without_better_conditions if the first element is not one of the logical prefixes, Array, or Hash" do
+      base.should_receive(:sanitize_sql_array_without_better_conditions).with(['conditions']).and_return('sql')
+      base.class_eval{ sanitize_sql_array_with_better_conditions(['conditions']) }.should == 'sql'
+    end
+    it "will delegate sub-expressions to sanitize_sql" do
+      base.should_receive(:sanitize_sql).with('exp').and_return('sanitized')
+      base.class_eval{ sanitize_sql_array_with_better_conditions([:not,'exp']) }.should == 'NOT (sanitized)'
+    end
+  end
+  describe '#sanitize_sql_with_better_conditions' do
+    it "returns 1=1 for true" do
+      base.class_eval{ sanitize_sql_with_better_conditions(true) }.should == '1=1'
+    end
+    it "returns 1=0 for false" do
+      base.class_eval{ sanitize_sql_with_better_conditions(false) }.should == '1=0'
+    end
+    it "calls the sanitize_sql_without_better_conditions for values other than true and false" do
+      base.should_receive(:sanitize_sql_without_better_conditions).with('other').and_return('expected')
+      base.class_eval{ sanitize_sql_with_better_conditions('other') }.should == 'expected'
+    end
+  end
+end

data/spec/entrails/active_record/find_by_association_spec.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Entrails::ActiveRecord::FindByAssociation do
+
+  def base
+    @base ||= Class.new do
+      stub!(:with_scope).and_return(nil)
+      stub!(:sanitize_sql).and_return('sql')
+      stub!(:sanitize_sql_array).and_return('sql')
+      stub!(:sanitize_sql_hash).and_return('sql')
+      extend Entrails::ActiveRecord::FindByAssociation
+    end
+  end
+
+  describe "#construct_find_by_association_conditions_sql" do
+    it "delegates to construct_find_by_association_conditions_nil_condition_sql when conditions is nil"
+    it "delegates to construct_find_by_association_conditions_nil_condition_sql when conditions is an empty Array"
+    it "delegates to construct_find_by_association_conditions_nil_condition_sql when conditions is an Array that contains a nil"
+    it "does not delegate to construct_find_by_association_conditions_subquery_sql when conditions is nil"
+    it "does not delegate to construct_find_by_association_conditions_subquery_sql when conditions is an empty Array"
+    it "does not delegate to construct_find_by_association_conditions_subquery_sql when conditions is an Array that contains only nils"
+  end
+
+  describe "#sanitize_sql_hash_with_find_by_association" do
+    it "calls original sanitize_sql_hash with a hash containing all keys that are *not* association names"
+    it "calls construct_find_by_association_sql for each key that is an association name"
+    it "calls reflect_on_association for each key to determine whether a it is an association name" do
+      mock_association = mock('association', :options => {}, :klass => 'class')
+      base.should_receive(:construct_find_by_association_conditions_sql).with(mock_association, 'conditions', :type => 'class')
+      base.should_receive(:reflect_on_association).with(:friends).exactly(:once).and_return(mock_association)
+      base.should_receive(:reflect_on_association).with(:name).exactly(:once).and_return(nil)
+      hash = { :name => 'alice', :friends => 'conditions' }
+      base.__send__(:sanitize_sql_hash_with_find_by_association, hash)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+ENV['LOG_NAME'] = 'spec'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+
+begin
+  require 'spec'
+  require 'activesupport'
+rescue LoadError
+  require 'rubygems'
+  require 'spec'
+  require 'activesupport'
+end
+
+require 'entrails'

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: brendan-entrails
+version: !ruby/object:Gem::Version 
+  version: 1.0.1
+platform: ruby
+authors: 
+- Brendan Baldwin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-20 00:00:00 -07:00
+default_executable: entrails
+dependencies: []
+
+description: "This is a collection of extensions to Rails internals that I've found to be absolutely indispensible since I implimented them.  The real action is happening in the following two files at the moment: http://github.com/brendan/entrails/tree/master/lib/entrails/active_record/better_conditions.rb http://github.com/brendan/entrails/tree/master/lib/entrails/active_record/find_by_association.rb"
+email: 
+- brendan@usergenic.com
+executables: 
+- entrails
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- bin
+- bin/entrails
+- entrails.gemspec
+- History.txt
+- init.rb
+- lib
+- lib/entrails
+- lib/entrails/active_record
+- lib/entrails/active_record/better_conditions.rb
+- lib/entrails/active_record/find_by_association.rb
+- lib/entrails/active_record.rb
+- lib/entrails.rb
+- Manifest.txt
+- Rakefile
+- README.txt
+- spec
+- spec/entrails
+- spec/entrails/active_record
+- spec/entrails/active_record/better_conditions_spec.rb
+- spec/entrails/active_record/find_by_association_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/brendan/entrails
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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.0.1
+signing_key: 
+specification_version: 2
+summary: "This is a collection of extensions to Rails internals that I've found to be absolutely indispensible since I implimented them.  The real action is happening in the following two files at the moment: http://github.com/brendan/entrails/tree/master/lib/entrails/active_record/better_conditions.rb http://github.com/brendan/entrails/tree/master/lib/entrails/active_record/find_by_association.rb"
+test_files: []
+