ryana-inequal_opportunity 0.1.0

data/README

@@ -0,0 +1,36 @@
+= Inequal Opportunity
+
+ActiveRecord is a ruby ORM released with Ruby on Rails.  It has a hash syntax
+for specifying SQL conditions:
+
+  YourModel.count(:conditions => {:id => 5})
+  YourModel.all(:limit => 5, :order => :created_at, :conditions => {:user_id => 5})
+
+But this hash format lacks inequalities.  In order to generate:
+
+  SELECT * from your_models where id <> '42';
+
+You have to write:
+
+  YourModel.count(:conditions => ['id <> ?', 42])
+
+With Inequal Opportunity, you can write:
+
+  YourModel.count(:conditions => {:id => ne(42)})
+
+Where Object#ne wraps 42 in a ActiveRecord::Inequality::NotEqual class,
+which is then used to insert the proper operator into the generated SQL.
+
+Test coverage is real sparse right now.  I also am not completely satisfied with
+the way I overwrite ActiveRecord.expand_range_bind_variables, but it works for now.
+
+
+== License
+
+Inequal Opportunity is released under the MIT license.
+
+
+== Support
+
+Just email me at ryan@angilly.com with questions, bugs,
+or patches

data/Rakefile

@@ -0,0 +1,11 @@
+begin
+    require 'jeweler'
+    Jeweler::Tasks.new do |gemspec|
+      gemspec.name = "inequal_opportunity"
+      gemspec.summary = "Adds mergable, stackable inequality statements to ActiveRecord conditions"
+      gemspec.email = "ryan@angilly.com"
+      gemspec.homepage = "http://github.com/ryana/inequal_opportunity"
+      gemspec.description = "Adds mergable, stackable inequality statements to ActiveRecord conditions"
+      gemspec.authors = ["Ryan Angilly"]
+    end
+end

data/lib/inequal_opportunity.rb

@@ -0,0 +1,124 @@
+module ActiveRecord
+  module Inequality
+
+    class Base
+      attr_accessor :value
+  
+      def initialize(val)
+        self.value = val
+      end
+
+      def operator
+        raise('Nope')
+      end
+    end
+
+    class GreaterThanEqual < Base
+      def operator
+        '>='
+      end
+    end
+
+    class GreaterThan < Base
+      def operator
+        '>'
+      end
+    end
+
+    class LessThanEqual < Base
+      def operator
+        '<='
+      end
+    end
+
+    class LessThan < Base
+      def operator
+        '<'
+      end
+    end
+
+    class NotEqual < Base
+      def operator
+        '<>'
+      end
+    end
+
+    class Like < Base
+      def operator
+        'LIKE'
+      end
+ 
+      def value
+        "%#{super}%"
+      end
+    end
+
+    module WrapperMethods
+
+      def lte(val)
+        ActiveRecord::Inequality::LessThanEqual.new(val)
+      end
+
+      def lt(val)
+        ActiveRecord::Inequality::LessThan.new(val)
+      end
+
+      def gte(val)
+        ActiveRecord::Inequality::GreaterThanEqual.new(val)
+      end
+
+      def gt(val)
+        ActiveRecord::Inequality::GreaterThan.new(val)
+      end
+
+      def ne(val)
+        ActiveRecord::Inequality::NotEqual.new(val)
+      end
+
+      def like(val)
+        ActiveRecord::Inequality::Like.new(val)
+      end
+
+    end
+
+  end
+
+  class Base
+    class << self
+      alias attribute_condition_orig attribute_condition
+      def attribute_condition(quoted_column_name, argument)
+        if argument.is_a? ActiveRecord::Inequality::Base
+          "#{quoted_column_name} #{argument.operator} ?"
+        else
+          attribute_condition_orig(quoted_column_name, argument)
+        end
+      end
+
+      # Copied this from AR.  Not ideal.
+      alias expand_range_bind_variables_orig expand_range_bind_variables
+      def expand_range_bind_variables(bind_vars)
+        expanded = []
+
+        bind_vars.each do |var|
+          next if var.is_a?(Hash)
+
+          if var.is_a?(Range)
+            expanded << var.first
+            expanded << var.last
+          elsif var.is_a?(ActiveRecord::Inequality::Base)
+            expanded << var.value
+          else
+            expanded << var
+          end
+        end
+
+        expanded
+      end
+
+    end
+  end
+
+end
+
+include ActiveRecord::Inequality::WrapperMethods
+

data/test/database.example.yml

@@ -0,0 +1,8 @@
+source:
+  adapter: mysql
+  database: 
+  host: localhost
+  port: 3306
+  username: 
+  password:  
+

data/test/inequal_opportunity_test.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'ruby-debug'
+
+DB = YAML::load(File.open(File.join(File.dirname(__FILE__), 'database.yml'))).symbolize_keys!
+ActiveRecord::Base.establish_connection(DB[:source])
+
+TABLES = %w(mains seconds)
+
+class Main < ActiveRecord::Base
+  belongs_to :seconds
+  named_scope :newer_than, lambda {|time| {:conditions => {:created_at => gte(time) }} }
+end
+
+class Second < ActiveRecord::Base
+  has_many :mains
+end
+
+#ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+class InequalOpportunityTest < Test::Unit::TestCase
+
+  def setup
+    TABLES.each do |t|
+      ActiveRecord::Base.connection.execute("create table #{t} (id integer, val integer, seconds_id integer, mains_id integer, created_at datetime default null);")
+    end
+  end
+
+  def teardown
+    TABLES.each do |t|
+      ActiveRecord::Base.connection.execute("drop table #{t};")
+    end
+  end
+
+  context "a model" do
+    setup do
+      @model = Main
+    end
+
+    should "respond to gte" do
+      assert @model.respond_to?(:gte)
+    end
+
+    should "should work with a named_scope" do
+      assert_equal Main.newer_than(2.days.ago), []
+    end
+
+    should "properly scope based on gte" do
+      time = 2.days.ago
+      num = 3
+      num.times { Main.create(:val => 3) }
+      num.times { Main.create(:val => 1) }
+
+      assert_equal Main.count(:conditions => {:val => gte(2)}), num
+    end
+
+  end
+
+  context "an instance" do
+    setup do
+      @main = Main.new
+    end
+
+    should "respond to gte" do
+      assert @main.respond_to?(:gte)
+    end
+
+  end
+
+  context "a parent" do
+    setup do
+      @second = Second.new
+    end
+
+    should "see through assocaitions" do
+      assert @second.mains.respond_to?(:gte)
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require File.dirname(__FILE__) + '/../init'

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: ryana-inequal_opportunity
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ryan Angilly
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Adds mergable, stackable inequality statements to ActiveRecord conditions
+email: ryan@angilly.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- Rakefile
+- lib/inequal_opportunity.rb
+- test/database.example.yml
+- test/inequal_opportunity_test.rb
+- test/test_helper.rb
+- README
+has_rdoc: true
+homepage: http://github.com/ryana/inequal_opportunity
+post_install_message: 
+rdoc_options: 
+- --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: Adds mergable, stackable inequality statements to ActiveRecord conditions
+test_files: 
+- test/inequal_opportunity_test.rb
+- test/test_helper.rb