active_record_query 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ar_query.gemspec
+gemspec

data/README.md

@@ -0,0 +1,150 @@
+# Active Record Query Plugin #
+
+Imaginatively named, I know.
+
+This is a proof-of-concept I want to be considered for inclusion in
+Rails 4.
+
+## Synopsis ##
+
+``` ruby
+Person.where { |q| q.name == 'Jon' && q.age == 22 }
+# => SELECT * FROM people WHERE people.name = 'Jon' AND people.age = 22
+
+Person.any { |q| q.name == 'Jon' || q.age == 22 }
+# => SELECT * FROM people WHERE people.name = 'Jon' OR people.age = 22
+
+Person.joins(:projects).where { |q| q.projects.name == 'Rails' }
+# => SELECT * FROM people INNER JOIN projects WHERE projecs.name = 'Rails'
+
+Person.any { |q| q.name = 'Jon' || q.and { q.age >= 10 && q.age < 30 } }
+# => SELECT * FROM people WHERE people.name = 'Jon' OR (people.age >= 10 AND people.age < 30)
+```
+
+## Why? ##
+
+*   Makes people (who use it) less vulnerable to accidentally introducing
+    SQL injection points
+
+*   If we have the AST, we can draw inferences from it in Active Record.
+    For example, in Rails 4,
+
+    ``` ruby
+    Post.includes(:comments).where('comments.created_at > x')
+    ```
+
+    will no longer `JOIN` the `comments` table. You have to do:
+
+    ``` ruby
+    Post.includes(:comments).where('comments.created_at > x').references(:comments)
+    ```
+
+    With the AST available to us, we can automatically infer that
+    `comments` is referenced.
+
+## Prior art ##
+
+* https://github.com/ernie/squeel
+* http://defunkt.io/ambition/
+
+## Design goals ##
+
+*   Don't use `instance_eval`. Here be dragons.
+
+*   Make the syntax as easy on the eyes as possible.
+
+    `&&` and `||`
+    cannot be redefined as methods (more about that below), but `&` and
+    `|` can be. However, they bind tighter than comparison operators,
+    resulting in lots of unpleasant parentheses:
+
+    ``` ruby
+    Person.where { |q| (q.name == 'Jon') & (q.age == 22) }
+    ```
+
+    `&` and `|` are also commonly used for set operations, which have an
+    existing meaning in SQL.
+
+## Implementation ##
+
+The `q` object is *mutable*.
+
+Writing,
+
+``` ruby
+Post.where { |q| q.name == 'Jon' && q.age == 22 }
+```
+
+has the identical effect as writing,
+
+``` ruby
+Post.where do |q|
+  q.name == 'Jon'
+  q.age == 22
+end
+```
+
+The `==` method return `true` to prevent the `&&` operator from
+short-circuiting. Using `&&` is purely syntactical sugar.
+
+Note that,
+
+``` ruby
+Post.where { |q| q.name == 'Jon' || q.age == 22 }
+```
+
+*would* short-circuit.
+
+So whilst this wouldn't throw an error, it at
+least would result in something that the user would (hopefully) notice
+is wrong quite quickly (because `age` would be missing from the query
+entirely).
+
+This 'hack' is definitely the worst thing about the idea, but I think
+that with adaquate documentation it wouldn't pose too much problem, and
+it reads quite naturally.
+
+## Supported operators ##
+
+``` ruby
+q.name == 'Jon'
+q.name != 'Jon'
+q.name =~ 'J%'
+q.name !~ 'J%'
+q.name > 22
+q.name < 22
+q.name >= 22
+q.name <= 22
+q.name.in ['Jon', 'Emily']
+q.name.not_in ['Jon', 'Emily']
+```
+
+## Possible alternative syntaxes ##
+
+### Option 1 (Squeel syntax) ###
+
+``` ruby
+Person.where { |q| (q.name == 'Jon') | (q.age == 22) }
+```
+
+* Doesn't require the `q.and { ... }` thing for `AND`-within-`OR` or
+  `OR`-within-`AND`
+* Possibly confusing use of set operators
+* Lots of parentheses
+
+### Option 2 ###
+
+``` ruby
+Person.where { |q| q.name == 'Jon'; q.age == 22 }
+```
+
+* This works already, it's a question of what we advocate / document.
+
+### Option 3 ###
+
+``` ruby
+Person.any { |q| q[:name] == 'Jon' || q.projects[:name] == 'Rails' }
+```
+
+* Draws a clearer distinction between table and column names
+* A bit more noisy

data/Rakefile

@@ -0,0 +1,19 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+namespace :test do
+  Rake::TestTask.new(:unit) do |t|
+    t.libs << "test"
+    t.test_files = FileList['test/unit/**/*_test.rb']
+    t.verbose = true
+  end
+
+  Rake::TestTask.new(:integration) do |t|
+    t.libs << "test"
+    t.test_files = FileList['test/integration/**/*_test.rb']
+    t.verbose = true
+  end
+end
+
+task :test => ['test:unit', 'test:integration']
+task :default => :test

data/active_record_query.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_record_query/version"
+
+Gem::Specification.new do |s|
+  s.name        = "active_record_query"
+  s.version     = ARQuery::VERSION
+  s.authors     = ["Jon Leighton"]
+  s.email       = ["j@jonathanleighton.com"]
+  s.homepage    = "https://github.com/jonleighton/active_record_query"
+  s.summary     = %q{Proof of concept for proposed new Active Record query API}
+  s.description = %q{Proof of concept for proposed new Active Record query API}
+
+  s.rubyforge_project = "ar_query"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'activerecord'
+
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'mocha'
+end

data/lib/active_record/query.rb

@@ -0,0 +1,57 @@
+require 'arel'
+
+module ActiveRecord
+  class Query < BasicObject
+    ::Kernel.require 'active_record/query/subject'
+    ::Kernel.require 'active_record/query/context'
+
+    CONTEXT = {
+      :or  => Or,
+      :and => And
+    }
+
+    attr_reader :table
+
+    def initialize(table, context)
+      @table = table
+      @nodes = []
+      @stack = [CONTEXT[context].new]
+    end
+
+    def method_missing(name, *args, &block)
+      if args.empty? && !block
+        Subject.new(self, name)
+      else
+        ::Kernel.raise ::ArgumentError
+      end
+    end
+
+    def respond_to?(name, include_private = nil)
+      true
+    end
+
+    def and
+      @stack << And.new
+      yield
+      self << @stack.pop.arel
+    end
+
+    def or
+      @stack << Or.new
+      yield
+      self << @stack.pop.arel
+    end
+
+    def <<(node)
+      @stack.last << node
+    end
+
+    def arel
+      @stack.last.arel
+    end
+
+    def inspect
+      "#<ActiveRecord::Query table=#{table.inspect}>"
+    end
+  end
+end

data/lib/active_record/query/context.rb

@@ -0,0 +1,39 @@
+class ActiveRecord::Query
+  class Context
+    attr_reader :nodes
+
+    def initialize
+      @nodes = []
+    end
+
+    def <<(node)
+      @nodes << node
+    end
+
+    def arel
+      Arel::Nodes::Grouping.new(nodes)
+    end
+  end
+
+  class Or < Context
+    def nodes
+      @nodes.inject { |mem, node| Arel::Nodes::Or.new(mem, node) }
+    end
+
+    def <<(node)
+      super
+      false
+    end
+  end
+
+  class And < Context
+    def nodes
+      Arel::Nodes::And.new(@nodes)
+    end
+
+    def <<(node)
+      super
+      true
+    end
+  end
+end

data/lib/active_record/query/subject.rb

@@ -0,0 +1,67 @@
+class ActiveRecord::Query
+  class Subject < BasicObject
+    def initialize(owner, name, table = nil)
+      @owner = owner
+      @name  = name
+      @table = table || @owner.table
+    end
+
+    def method_missing(method_name, *args, &block)
+      if args.empty? && !block
+        Subject.new(@owner, method_name, ::Arel::Table.new(@name))
+      else
+        ::Kernel.raise ::ArgumentError
+      end
+    end
+
+    def respond_to?(name, include_private = nil)
+      true
+    end
+
+    def ==(value)
+      __add__ :eq, value
+    end
+
+    def !=(value)
+      __add__ :not_eq, value
+    end
+
+    def =~(value)
+      __add__ :matches, value
+    end
+
+    def !~(value)
+      __add__ :does_not_match, value
+    end
+
+    def >(value)
+      __add__ :gt, value
+    end
+
+    def <(value)
+      __add__ :lt, value
+    end
+
+    def >=(value)
+      __add__ :gteq, value
+    end
+
+    def <=(value)
+      __add__ :lteq, value
+    end
+
+    def in(value)
+      __add__ :in, value
+    end
+
+    def not_in(value)
+      __add__ :not_in, value
+    end
+
+    private
+
+    def __add__(operator, value)
+      @owner << @table[@name].send(operator, value)
+    end
+  end
+end

data/lib/active_record_query.rb

@@ -0,0 +1,4 @@
+require 'active_record/query'
+
+require 'active_record_query/version'
+require 'active_record_query/relation_extension'

data/lib/active_record_query/relation_extension.rb

@@ -0,0 +1,33 @@
+require 'active_support/core_ext/module/delegation'
+
+module ActiveRecordQuery
+  module RelationExtension
+    def where(*args)
+      if args.empty? && block_given?
+        query = ActiveRecord::Query.new(table, :and)
+        yield query
+        super query.arel
+      else
+        super
+      end
+    end
+
+    def any
+      query = ActiveRecord::Query.new(table, :or)
+      yield query
+      where(query.arel)
+    end
+  end
+end
+
+if defined?(ActiveRecord::Base)
+  require 'active_record/relation'
+
+  class ActiveRecord::Relation
+    include ActiveRecordQuery::RelationExtension
+  end
+
+  class << ActiveRecord::Base
+    delegate :any, :to => :scoped
+  end
+end

data/lib/active_record_query/version.rb

@@ -0,0 +1,3 @@
+module ARQuery
+  VERSION = "0.1.0"
+end

data/test/helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'active_record_query'
+require 'minitest/autorun'
+require 'mocha'

data/test/integration/query_test.rb

@@ -0,0 +1,99 @@
+require 'active_record'
+require 'helper'
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Schema.define do
+  create_table :posts do |t|
+    t.string :title
+  end
+
+  create_table :comments do |t|
+    t.references :post
+    t.string :author
+  end
+end
+
+class Post < ActiveRecord::Base
+  has_many :comments
+end
+
+class Comment < ActiveRecord::Base
+end
+
+module ActiveRecord
+  class QueryIntegrationTest < MiniTest::Unit::TestCase
+    def setup
+      @hello   = Post.create(title: 'Hello')
+      @goodbye = Post.create(title: 'Goodbye')
+
+      @hello.comments.create(author: 'Jon')
+    end
+
+    def teardown
+      Post.delete_all
+    end
+
+    # Checks that none of the operators blow up
+    def test_operators
+      Post.where do |q|
+        q.title == 'x'
+        q.title != 'x'
+        q.title =~ 'x'
+        q.title !~ 'x'
+        q.title > 'x'
+        q.title < 'x'
+        q.title >= 'x'
+        q.title <= 'x'
+        q.title.in 'x'
+        q.title.not_in 'x'
+      end
+    end
+
+    def test_basic_query
+      assert_equal [@hello], Post.where { |q| q.title == 'Hello' }
+    end
+
+    def test_and_query
+      assert_equal [@hello], Post.where { |q| q.title == 'Hello' && q.title =~ 'Hell%' }
+      assert_equal [], Post.where { |q| q.title == 'Hello' && q.title == 'Goodbye' }
+    end
+
+    def test_or_query
+      assert_equal [@hello, @goodbye], Post.any { |q| q.title == 'Hello' || q.title == 'Goodbye' }
+      assert_equal [@hello], Post.any { |q| q.title == 'Hello' || q.title == 'non-existent' }
+      assert_equal [@hello], Post.any { |q| q.title == 'non-existent' || q.title == 'Hello' }
+    end
+
+    def test_other_table_query
+      assert_equal [@hello], Post.joins(:comments).where { |q| q.comments.author == 'Jon' }
+      assert_equal [], Post.joins(:comments).where { |q| q.comments.author == 'Bob' }
+    end
+
+    def test_nested_contexts
+      query = Post.any { |q|
+        q.title == 'non-existent' ||
+        q.and {
+          q.title == 'Hello' &&
+          q.or {
+            q.title == 'other' ||
+            q.title =~ 'Hell%'
+          }
+        }
+      }
+
+      assert query.to_sql.include?(
+        %q{("posts"."title" = 'non-existent' OR ("posts"."title" = 'Hello' AND ("posts"."title" = 'other' OR "posts"."title" LIKE 'Hell%')))}
+      )
+
+      assert_equal [@hello], query
+
+      query = Post.any { |q| q.and { q.title == 'a' && q.title == 'b' } || q.title == 'c' }
+
+      assert query.to_sql.include?(
+        %q{(("posts"."title" = 'a' AND "posts"."title" = 'b') OR "posts"."title" = 'c')}
+      )
+    end
+  end
+end

data/test/unit/query/subject_test.rb

@@ -0,0 +1,108 @@
+require 'helper'
+
+class SubjectTest < MiniTest::Unit::TestCase
+  class Column
+    attr_reader :table, :name
+
+    def initialize(table, name)
+      @table = table
+      @name  = name
+    end
+
+    def ==(other)
+      other.class == self.class &&
+        other.table == table &&
+        other.name  == name
+    end
+
+    PREDICATES = [:eq, :not_eq, :matches, :does_not_match, :gt, :lt, :gteq, :lteq, :in, :not_in]
+
+    PREDICATES.each do |pred|
+      define_method pred do |other|
+        [pred, self, other]
+      end
+    end
+  end
+
+  class Table
+    def [](name)
+      Column.new(self, name)
+    end
+  end
+
+  def setup
+    @owner   = stub
+    @table   = Table.new
+    @subject = ActiveRecord::Query::Subject.new(@owner, :foo, @table)
+    @column  = @table[:foo]
+  end
+
+  def test_equality
+    @owner.expects(:<<).with(@column.eq(:bar))
+    @subject == :bar
+  end
+
+  def test_inequality
+    @owner.expects(:<<).with(@column.not_eq(:bar))
+    @subject != :bar
+  end
+
+  def test_matches
+    @owner.expects(:<<).with(@column.matches(:bar))
+    @subject =~ :bar
+  end
+
+  def test_does_not_match
+    @owner.expects(:<<).with(@column.does_not_match(:bar))
+    @subject !~ :bar
+  end
+
+  def test_gt
+    @owner.expects(:<<).with(@column.gt(:bar))
+    @subject > :bar
+  end
+
+  def test_lt
+    @owner.expects(:<<).with(@column.lt(:bar))
+    @subject < :bar
+  end
+
+  def test_gteq
+    @owner.expects(:<<).with(@column.gteq(:bar))
+    @subject >= :bar
+  end
+
+  def test_lteq
+    @owner.expects(:<<).with(@column.lteq(:bar))
+    @subject <= :bar
+  end
+
+  def test_in
+    @owner.expects(:<<).with(@column.in(:bar))
+    @subject.in(:bar)
+  end
+
+  def test_not_in
+    @owner.expects(:<<).with(@column.not_in(:bar))
+    @subject.not_in(:bar)
+  end
+
+  def test_method_missing
+    table = stub
+    sub2  = stub
+
+    Arel::Table.expects(:new).with(:foo).returns(table)
+    ActiveRecord::Query::Subject.expects(:new).with(@owner, :bar, table).returns(sub2)
+
+    assert_equal sub2, @subject.bar
+  end
+
+  def test_method_missing_with_args
+    assert_raises(ArgumentError) { @subject.bar(:foo) }
+    assert_raises(ArgumentError) { @subject.bar { :foo } }
+  end
+
+  def test_respond_to
+    assert @subject.respond_to?(:bar)
+  end
+end

data/test/unit/query_test.rb

@@ -0,0 +1,57 @@
+require 'helper'
+
+module ActiveRecord
+  class QueryTest < MiniTest::Unit::TestCase
+    def setup
+      @table = :table
+      @query = Query.new(@table, :and)
+      class << @query; include ::Mocha::ObjectMethods; end
+    end
+
+    def test_method_missing
+      assert_raises(ArgumentError) { @query.title(:foo) }
+      assert_raises(ArgumentError) { @query.title { :foo } }
+
+      subject = stub
+      Query::Subject.expects(:new).with(@query, :title).returns(subject)
+      assert_equal subject, @query.title
+    end
+
+    def test_respond_to
+      assert @query.respond_to?(:title)
+    end
+
+    def test_table
+      assert_equal @table, @query.table
+    end
+
+    def test_push
+      @query << :foo
+      @query << :bar
+
+      assert_equal [:foo, :bar], @query.arel.expr.children
+    end
+
+    def test_inspect
+      assert_equal "#<ActiveRecord::Query table=:table>", @query.inspect
+    end
+
+    def test_and
+      subcontext = stub(:arel => stub)
+      subject    = stub
+      Query::And.expects(:new).returns(subcontext)
+
+      @query.and { }
+      assert_equal [subcontext.arel], @query.arel.expr.children
+    end
+
+    def test_or
+      subcontext = stub(:arel => stub)
+      subject    = stub
+      Query::Or.expects(:new).returns(subcontext)
+
+      @query.or { }
+      assert_equal [subcontext.arel], @query.arel.expr.children
+    end
+  end
+end

data/test/unit/relation_extension_test.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+module ActiveRecordQuery
+  class RelationExtensionTest < MiniTest::Unit::TestCase
+    class FakeRelation
+      module Where
+        attr_reader :where_values
+
+        def where(*args)
+          @where_values = args
+        end
+      end
+
+      include Where
+      include RelationExtension
+
+      def table
+        :table
+      end
+    end
+
+    def setup
+      @relation = FakeRelation.new
+      @query    = stub(:arel => stub)
+    end
+
+    def test_where_with_args
+      @relation.where :foo
+      assert_equal [:foo], @relation.where_values
+
+      @relation.where(:foo) { :bar }
+      assert_equal [:foo], @relation.where_values
+    end
+
+    def test_where_with_block
+      ActiveRecord::Query.expects(:new).with(:table, :and).returns(@query)
+
+      query = nil
+      @relation.where { |q| query = q }
+
+      assert_equal @query, query
+      assert_equal [@query.arel], @relation.where_values
+    end
+
+    def test_any
+      ActiveRecord::Query.expects(:new).with(:table, :or).returns(@query)
+
+      query = nil
+      @relation.any { |q| query = q }
+
+      assert_equal @query, query
+      assert_equal [@query.arel], @relation.where_values
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: active_record_query
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jon Leighton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &15665600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *15665600
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &15698260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *15698260
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &15719140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *15719140
+description: Proof of concept for proposed new Active Record query API
+email:
+- j@jonathanleighton.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- active_record_query.gemspec
+- lib/active_record/query.rb
+- lib/active_record/query/context.rb
+- lib/active_record/query/subject.rb
+- lib/active_record_query.rb
+- lib/active_record_query/relation_extension.rb
+- lib/active_record_query/version.rb
+- test/helper.rb
+- test/integration/query_test.rb
+- test/unit/query/subject_test.rb
+- test/unit/query_test.rb
+- test/unit/relation_extension_test.rb
+homepage: https://github.com/jonleighton/active_record_query
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: ar_query
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Proof of concept for proposed new Active Record query API
+test_files:
+- test/helper.rb
+- test/integration/query_test.rb
+- test/unit/query/subject_test.rb
+- test/unit/query_test.rb
+- test/unit/relation_extension_test.rb
+has_rdoc: