relata 0.0.3

data/Gemfile

@@ -0,0 +1,3 @@
+source :gemcutter
+gem 'sqlite3-ruby', :require => 'sqlite3'
+gem 'ruby-debug19', :require => "ruby-debug"

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 [name of plugin creator]
+
+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/README.markdown

@@ -0,0 +1,43 @@
+#FilteredRelation#
+
+Making dynamic filters easier with a nice ActiveRecord DSL. 
+
+## Filter Example ##
+
+Create dynamic filters with just onde method.
+	
+	<% form_tag :action => 'filter' do %>
+	  	Title: <%= text_field_tag 'post[title]' %><br />
+	  	Only with Comments? 
+	        <%= select("post", "comments",   options_for_select({ "false" => "", "true" => "true" })) %> %>
+
+	def filter
+	  @posts = Post.filtered_relation(params[:post]).all
+	end
+
+Create more advanced relations.
+	
+	posts = Post.filtered_relation(:comments => true).where(:user_id => 4).limit(3).order("id ASC") 



+
+	posts.each do |post| 

+		# records
+	end 

+
+## DSL API ##
+
+	Post.where(:body).like?("%caelum%")
+
+	Post.where(:comments).count.exists?
+
+	Post.where(:comments).count.gt(2)
+
+	Post.where(:comments).count.lt(2)
+
+ 	Post.where(:comments).description.like?("%filtered%")
+
+ 	Post.where(:comments).subject.like?("%filtered%")
+
+	Post.where { comments >= 2 }
+	
+	Post.where { published_at.between(2.years.ago, 6.months.ago) }
+    

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the relata plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the relata plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'relata'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.markdown')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+PKG_FILES = FileList[ '[a-zA-Z]*', 'generators/**/*', 'lib/**/*', 'rails/**/*', 'tasks/**/*', 'test/**/*' ] 
+
+spec = Gem::Specification.new do |s|
+   s.name = "relata"  
+   s.version = "0.0.3"  
+   s.author = "Anderson Leite, Guilherme Silveira"  
+   s.email = "anderson.leite@caelum.com.br"  
+   s.homepage = "http://github.com/caelum/relata"  
+   s.platform = Gem::Platform::RUBY 
+   s.summary = "Helps poking around with relationships when using ARel"
+   s.files = PKG_FILES.to_a 
+   s.require_path = "lib"  
+   s.has_rdoc = false 
+   s.extra_rdoc_files = ["README.markdown"] 
+end 
+
+desc 'Turn this plugin into a gem.' 
+Rake::GemPackageTask.new(spec) do |pkg| 
+  pkg.gem_spec = spec 
+end

data/init.rb

@@ -0,0 +1,7 @@
+$:.unshift(File.join(File.dirname(__FILE__), "lib"))
+
+require 'ruby-debug'
+require 'active_record'
+require "active_support"
+
+require "filtered_relation"

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/filtered_relation.rb

@@ -0,0 +1,3 @@
+module FilteredRelation
+  require 'filtered_relation/filter'
+end

data/lib/relata/dsl/conditions.rb

@@ -0,0 +1,45 @@
+# A custom set of conditions that can be applied
+# to a query
+module Relata::Dsl::Conditions
+
+  def eq(value)
+    add_filter("= #{value}")
+  end
+
+  def ge(value)
+    add_filter(">= #{value}")
+  end
+
+  def greater_or_equals(value)
+    ge(value)
+  end
+  
+  def gt(value)
+    add_filter("> #{value}")
+  end
+
+  def greater_than(value)
+    gt(value)
+  end
+
+  def le(value)
+    add_filter("<= #{value}")
+  end
+
+  def lt(value)
+    add_filter("< #{value}")
+  end
+
+  def lesser_than(value)
+    lt value
+  end
+
+  # whether this relation has at least one element.
+  def exists?
+    if @relation_search.nil?
+      count.exists?
+    else
+      add_filter("> 0")
+    end
+  end  
+end

data/lib/relata/dsl/constraints.rb

@@ -0,0 +1,62 @@
+module Relata::Dsl::Constraints
+  
+  def length
+    @relation_search = LengthManager
+    self
+  end
+  
+  class LengthManager
+    def self.condition(field, *args)
+      "len(field)"
+    end
+  end
+
+  def count
+    @select_fields << "COUNT(#{@current_field}.id) AS count"
+    @groups << "#{table_name}.id"
+    @relation_search = 'count'
+    self
+  end
+
+  def like?(value)
+    query.where("#{@current_field} like ?", [value])
+  end
+  
+  # def between(first, second)
+  #   @relation_search = SimpleRangeCondition
+  #   self
+  #   # query.where("#{@current_field} like ?", [value])
+  #   # add_filter("> #{first}").add_filter("< #{second}")
+  # end
+  
+  class SimpleCondition
+    def self.condition(field, *args)
+      "#{field}"
+    end
+  end
+
+  class SimpleRangeCondition
+    def self.condition(field, *args)
+      "#{field} > #{args[0]} AND #{field} < #{args[1]}"
+    end
+  end
+
+  class RangeManager
+    def self.select_fields(facet)
+      "COUNT(#{facet}.id) AS count"
+    end
+    def self.having(expectation)
+      "count #{expectation}"
+    end
+  end
+
+  class CountManager
+    def self.select_fields(facet)
+      "COUNT(#{facet}.id) AS count"
+    end
+    def self.having(expectation)
+      "count #{expectation}"
+    end
+  end
+
+end

data/lib/relata/dsl/custom_relation.rb

@@ -0,0 +1,26 @@
+# defines helper methods to deal with custom relation
+module Relata::Dsl::CustomRelation
+  include Relata::Dsl::Conditions
+  include Relata::Dsl::Constraints
+  
+  def using(record, field)    
+    @record = record
+    @current_field = field
+    @start_field = field
+    @select_fields = ["#{table_name}.*"]
+    @groups = []
+    if relates_to_many?
+      self.extend MultipleQuery
+      self.extend ModelFields      
+    else
+      self.extend SimpleQuery
+    end
+    
+    self
+  end
+
+  def relates_to_many?
+    @record.reflect_on_association @current_field.to_sym
+  end
+
+end

data/lib/relata/dsl/field_search.rb

@@ -0,0 +1,85 @@
+# a relation search in a specific field
+class Relata::Dsl::FieldSearch
+  
+  def initialize(rel, field)
+    @rel = rel
+    @field = field
+  end
+
+  def ==(value)
+    @rel.where("#{@field} == ?", value)
+  end
+
+  def >=(value)
+    @rel.where("#{@field} >= ?", value)
+  end
+  
+  def <=(value)
+    @rel.where("#{@field} <= ?", value)
+  end
+  
+  def >(value)
+    @rel.where("#{@field} > ?", value)
+  end
+  
+  def <(value)
+    @rel.where("#{@field} < ?", value)
+  end
+  
+  def like?(value)
+    @rel.where(@field).like?(value)
+  end
+  
+  def between(first, second)
+    @rel.where("#{@field} > ? and #{@field} < ?", first, second)
+  end
+  
+  def length
+    @field = "length(#{@field})"
+    self
+  end
+  
+  def custom(*args)
+    comparison = args.shift
+    @rel.where("#{@field} #{comparison}", args)
+  end
+
+end
+
+class Relata::Dsl::FieldSearchMany
+  
+  def initialize(rel, field)
+    @rel = rel
+    @field = field
+  end
+
+  def ==(value)
+    @rel.where(@field).count.eq(value)
+  end
+
+  def >=(value)
+    @rel.where(@field).count.ge(value)
+  end
+  
+  def <=(value)
+    @rel.where(@field).count.le(value)
+  end
+  
+  def >(value)
+    @rel.where(@field).count.gt(value)
+  end
+  
+  def <(value)
+    @rel.where(@field).count.lt(value)
+  end
+  
+  def exists?
+    @rel.where(@field).exists?
+  end
+  
+  def custom(*args)
+    comparison = args.shift
+    @rel.where("#{@field} #{comparison}", args)
+  end
+
+end

data/lib/relata/dsl/missed_builder.rb

@@ -0,0 +1,28 @@
+# a builder ready to collect which field you want to search
+class Relata::Dsl::MissedBuilder
+  
+  def initialize(rel)
+    @rel = rel
+  end
+  
+  def method_missing(field, *args)
+    relation = @rel.scoped
+    relation.extend Relata::Dsl::CustomRelation
+    relation.using(@rel, field)
+    
+    if relation.relates_to_many?
+      type = Relata::Dsl::FieldSearchMany
+    else
+      type = Relata::Dsl::FieldSearch
+    end
+    
+    instance = type.new(relation, field)
+    
+    if args.size != 0
+      instance = instance.custom(*args)
+    end
+    
+    instance
+  end
+  
+end

data/lib/relata/dsl/querys/fields.rb

@@ -0,0 +1,25 @@
+module ModelFields
+  
+  def self.extended(base)
+    
+    base.reflect_on_all_associations.each do |r|
+      @fields = r.klass.columns.map do |c|
+        c.name if [:string, :text].include? c.type
+      end  
+    end  
+    
+    @fields.each do |field|
+      include_method field if field != nil
+    end  
+     
+  end
+ 
+  private
+  def self.include_method(field)
+    define_method field do 
+      @current_field = "#{@current_field}.#{field}"
+      self
+    end
+  end
+  
+end

data/lib/relata/dsl/querys/multiple.rb

@@ -0,0 +1,8 @@
+module MultipleQuery
+  def query
+    preload(@start_field).select(@select_fields.join ',').from("#{table_name}, #{@start_field}").where("#{table_name}.id = #{@start_field}.post_id")
+  end
+  def add_filter expectation
+    query.group(@groups.first).having("#{@relation_search} #{expectation}") 
+  end
+end

data/lib/relata/dsl/querys/simple.rb

@@ -0,0 +1,11 @@
+module SimpleQuery
+  def query
+    self
+  end
+  
+  def add_filter *expectation
+    base = @relation_search.condition(@current_field.to_s, expectation)
+    where("#{base} #{expectation}")
+  end
+  
+end

data/lib/relata/dsl.rb

@@ -0,0 +1,41 @@
+# in case you did not require the entire relata plugin
+module Relata
+  module Dsl
+  end
+end
+
+require 'relata/dsl/conditions'
+require 'relata/dsl/constraints'
+require 'relata/dsl/custom_relation'
+require 'relata/dsl/field_search'
+require 'relata/dsl/missed_builder'
+require 'relata/dsl/querys/multiple'
+require 'relata/dsl/querys/simple'
+require 'relata/dsl/querys/fields'
+
+module Relata::Dsl::Relation
+
+  # extended where clause that allows symbol and custom dsl lookup
+  #
+  # examples:
+  # where(:body).like?("%guilherme%")
+  # where { body.like?("%guilherme%")
+  #
+  # While the last will delegate to the MissedBuilder component
+  # the symbol based query will delegate query builder to CustomRelation.
+  def where(*args, &block)
+    if args.size==0 && block
+      Relata::Dsl::MissedBuilder.new(self).instance_eval(&block)
+    elsif args.size==1 && args[0].is_a?(Symbol)
+      relation = scoped
+      relation.extend Relata::Dsl::CustomRelation
+      relation.using(self, args[0])
+    else
+      super(*args, &block)
+    end
+  end
+end
+
+class ActiveRecord::Relation
+  include Relata::Dsl::Relation
+end

data/lib/relata/filter.rb

@@ -0,0 +1,46 @@
+require 'filtered_relation/related_query_methods'
+ActiveRecord::Base.send :include, RelatedQueryMethods
+
+module FilteredRelation
+
+  class ::ActiveRecord::Base
+
+    def self.filtered_relation(params) 
+      relation = scoped 
+
+      columns = self.columns.map do |c|
+         c.name if [:string, :text].include? c.type
+      end  
+                  
+      params.each do |facet, value| 
+        if self.reflect_on_association facet.to_sym
+          relation = send("filter_by_has_many", facet, value, relation)           
+        elsif columns.include? facet.to_s
+          relation = send("filter_by_exact", facet, value, relation)
+        else    
+          relation = send("filter_by_#{facet}", value, relation)         
+        end
+      end
+
+      relation
+    end
+
+    def self.related_to(params) 
+      relation = scoped 
+
+      params.each do |facet, value| 
+        relation = send("filter_by_related", facet, value, relation) 
+      end
+      relation
+    end
+
+    def self.date_between(params) 
+      relation = scoped 
+      relation = send("filter_by_date_between", params, relation) 
+      relation
+    end
+
+
+  end
+
+end

data/lib/relata/related_query_methods.rb

@@ -0,0 +1,44 @@
+module RelatedQueryMethods
+  
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+
+      def filter_by_has_many(facet, value, relation) 
+        
+        table_name = self.table_name
+
+        if !value.empty?
+          relation.preload(facet).select("#{table_name}.*, COUNT(#{facet}.id) AS count").from("#{table_name}, #{facet}").where("#{table_name}.id = #{facet}.post_id").group("#{table_name}.id").having("count > 0") 
+        else 
+          relation 
+        end 
+      end
+
+      def filter_by_related(facet, value, relation) 
+        if value 
+          relation.preload(facet).select("posts.*, COUNT(#{facet}.id) AS comment_count").from("posts, #{facet}").group("posts.id").having("comment_count > 0") 
+        else 
+          relation 
+        end 
+      end
+
+      def filter_by_exact(facet, value, relation) 
+        !value.empty? ? relation.where(facet => value) : relation
+      end
+
+      def filter_by_published_at(value, relation) 
+        value ? relation.where("published_at < ?", 1.month.ago) : relation 
+      end
+      
+      def filter_by_date_between(params, relation) 
+        relation.where("published_at < ?", params[:before])
+        relation.where("published_at > ?", params[:after])
+        relation
+      end
+
+  end
+    
+end

data/test/dsl_test.rb

@@ -0,0 +1,187 @@
+require File.expand_path(File.dirname(__FILE__)) + "/test_helper"
+require 'schema'
+require 'relata/dsl'
+
+class DSLTest < ActiveSupport::TestCase
+  
+  setup do
+    setup_db
+    @caelum = Post.create :body => "CaelumObjects training and inovation"
+    @guilherme = Post.create :body => "Guilherme Silveira"
+  end
+  
+  test "given an attribute and expectation, gives the results" do
+    posts = Post.where(:body).like?("%caelum%").all
+    assert_equal @caelum, posts[0]
+    assert_equal 1, posts.size
+
+    posts = Post.where { body.like? "%caelum%" }
+    assert_equal @caelum, posts[0]
+    assert_equal 1, posts.size
+  end
+  
+  test "given an attribute and constraint expectation, gives the results" do
+    posts = Post.where { body.length < 22 }
+    assert_equal @guilherme, posts[0]
+    assert_equal 1, posts.size
+  end
+  
+  test "exists posts with comments" do
+    @caelum.update_attributes(:comments => [Comment.create]) 
+    posts = Post.where(:comments).count.exists?
+    assert_equal @caelum, posts[0]
+    assert_equal 1, posts.size
+  end
+  
+  test "exists posts with comments can be shortcuted with exists?" do
+    @caelum.update_attributes(:comments => [Comment.create]) 
+    posts = Post.where(:comments).exists?
+    assert_equal @caelum, posts[0]
+    assert_equal 1, posts.size
+
+    posts = Post.where { comments.exists? }
+    assert_equal @caelum, posts[0]
+    assert_equal 1, posts.size
+  end
+  
+  test "exists posts with more than 2 comments" do
+    @caelum.update_attributes(:comments => [Comment.create, Comment.create, Comment.create]) 
+    posts = Post.where(:comments).count.gt(2)
+    assert_equal @caelum, posts.first
+    assert_equal 3, posts.first.comments.size
+  end
+  
+  test "exists posts with less than 2 comments" do
+    @caelum.update_attributes(:comments => [Comment.create]) 
+    posts = Post.where(:comments).count.lt(2)
+    assert_equal @caelum, posts.first
+    assert_equal 1, posts.first.comments.size
+  end
+  
+  test "exists posts with more than or equals 2 comments" do
+    @caelum.update_attributes(:comments => [Comment.create, Comment.create]) 
+    @guilherme.update_attributes(:comments => [Comment.create, Comment.create, Comment.create])
+
+    posts = Post.where(:comments).count.ge(2).all
+    assert_equal 2, posts.size
+    assert_equal @caelum, posts[0]
+    assert_equal @guilherme, posts[1]
+  end
+   
+  test "dsl query supports first" do
+    @caelum.update_attributes(:comments => [Comment.create, Comment.create]) 
+    @guilherme.update_attributes(:comments => [Comment.create, Comment.create, Comment.create])
+
+    posts = Post.where(:comments).count.ge(2).first
+    assert_equal @caelum, posts
+  end
+
+#    pending
+  # test "all post which commits has some description" do
+  #   comment = Comment.create :description => "dsl test"
+  #   @caelum.update_attributes :comments => [comment]
+  # 
+  #   posts = Post.where(:comments).description.like?("%dsl test%")
+  #   assert_equal @caelum, posts[0]
+  #   assert_equal 1, posts.size
+  # 
+  # end
+
+  test "exists posts using strict extended methods" do
+    @caelum.update_attributes(:comments => [Comment.create, Comment.create]) 
+    @guilherme.update_attributes(:comments => [Comment.create, Comment.create, Comment.create])
+    posts = Post.where { comments >= 2 }
+    assert_equal @caelum, posts[0]
+    assert_equal 2, posts.size
+    assert_equal @guilherme, posts[1]
+  end
+
+  test "strict block supports first" do
+    @caelum.update_attributes(:comments => [Comment.create, Comment.create]) 
+    @guilherme.update_attributes(:comments => [Comment.create, Comment.create, Comment.create])
+    post = Post.where { comments >= 2 }.first
+    assert_equal @caelum, post
+  end
+
+  test "exists posts using range expectations" do
+    @caelum.update_attributes :published_at => 1.year.ago
+    
+    posts = Post.where { published_at.between(2.years.ago, 6.months.ago) }
+    assert_equal @caelum, posts[0]
+    assert_equal 1, posts.size
+  end
+
+# pending
+  # test "all post which commits has some subject" do
+  #   comment = Comment.create :subject => "dsl subject"
+  #   @caelum.update_attributes :comments => [comment]
+  #   posts = Post.where(:comments).subject.like?("%dsl subject%")
+  #   assert_equal @caelum, posts[0]
+  #   assert_equal 1, posts.size
+  # end
+  
+  test "accepts two conditions inline" do
+    @caelum.update_attributes :published_at => 1.year.ago
+    @guilherme.update_attributes :published_at => 1.year.ago
+    
+    posts = Post.where { 
+      published_at.between(2.years.ago, 6.months.ago)
+      body.like?("%lum%")
+    }
+    assert_equal @caelum, posts[0]
+    assert_equal 1, posts.size
+  end
+
+  test "supports two conditions in dsl mixing everything together" do
+    @caelum.update_attributes(:comments => [Comment.create, Comment.create]) 
+    @guilherme.update_attributes(:comments => [Comment.create, Comment.create, Comment.create])
+    posts = Post.where { comments >= 1 }.where(:body).like?("%lum%")
+    assert_equal @caelum, posts[0]
+    assert_equal 1, posts.size
+  end
+
+  test "supports == with relation count" do
+    @caelum.update_attributes(:comments => [Comment.create, Comment.create]) 
+    posts = Post.where { comments == 2 }
+    assert_equal @caelum, posts[0]
+    assert_equal 1, posts.size
+  end
+
+  test "supports == with simple field" do
+    @caelum.update_attributes(:comments => [Comment.create, Comment.create]) 
+    posts = Post.where { body == "CaelumObjects training and inovation" }
+    assert_equal @caelum, posts[0]
+    assert_equal 1, posts.size
+  end
+
+  test "accepts two conditions one after the other" do
+    @caelum.update_attributes :published_at => 1.year.ago
+    @guilherme.update_attributes :published_at => 1.year.ago
+    
+    posts = Post.where { published_at.between(2.years.ago, 6.months.ago) }
+    assert_equal @caelum, posts[0]
+    assert_equal 2, posts.size
+    posts = posts.where { body.like?("%lum%") }
+    assert_equal @caelum, posts[0]
+    assert_equal 1, posts.size
+  end
+
+  test "accepts any custom condition" do
+    posts = Post.where { body "like ?", "%lum%" }
+    assert_equal @caelum, posts[0]
+    assert_equal 1, posts.size
+  end
+
+  # test "second level relation in a dsl" do
+  #   comment = Comment.create :description => "dsl test"
+  #   @caelum.update_attributes :comments => [comment]
+  # 
+  #   posts = Post.where{ comments.description.like?("%dsl test%") }
+  #   assert_equal @caelum, posts[0]
+  #   assert_equal 1, posts.size
+  # 
+  # end
+
+    # Author.where(:posts).comments.count.gt(2)
+    
+end

data/test/filtered_relation_test.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.dirname(__FILE__)) + "/test_helper"
+
+require 'filtered_relation/filter'
+require 'schema'
+
+class FilteredRelationTest < ActiveSupport::TestCase
+  setup do
+    setup_db
+    create_posts
+  end
+  
+   test "given no values to filtered_relation, gives us all records" do
+      assert_equal Post.all, Post.filtered_relation({}).all
+    end
+   
+    test "given a content and comment filter, gives us filtered records - generic" do 
+      @base.update_attributes(:content => "picture", :comments => [Comment.create]) 
+      assert_equal @base, Post.filtered_relation(:content => "picture", :comments => 'true').first 
+    end
+    
+    test "given a content and comment filter, gives us filtered records" do 
+      @base.update_attributes(:content => "picture", :comments => [Comment.create]) 
+      assert_equal @base, Post.filtered_relation(:content => "picture").related_to(:comments => true).first 
+    end
+    
+    test "given a date and comment filter, gives us filtered records" do 
+      @base.update_attributes(:published_at => 2.years.ago, :comments => [Comment.create]) 
+      assert_equal @base, Post.filtered_relation(:published_at => true).related_to(:comments => true).first 
+    end 
+   
+    test "given a date and content filter, gives us filtered records" do 
+      @base.update_attribute(:published_at, 2.years.ago) 
+      @base.update_attribute(:content, "picture") 
+      record = Post.filtered_relation(:published_at => true, :content => "picture").first 
+      
+      assert_equal @base, record 
+    end
+    
+    test "given two dates, gives us filtered records between this date" do 
+      assert_equal @base, Post.date_between(:before => 1.year.ago, :after => Time.now).first 
+    end 
+    
+    test "return a post with same title" do 
+      @base.update_attributes(:title => "Post Title") 
+      assert_equal @base, Post.filtered_relation(:title => "Post Title").first 
+    end
+    
+    test "return a post with same title and body" do 
+      @base.update_attributes(:title => "Post Title", :body => "Ruby") 
+      assert_equal @base, Post.filtered_relation(:title => "Post Title", :body => "Ruby").first 
+    end
+    
+  
+  def create_posts
+    valid_attributes = {
+      :body => "Hello.",
+      :title => "Hi!",
+      :content => "text",
+      :user_id => 1,
+      :published_at => Time.now
+    }
+    
+    @base = Post.create(valid_attributes)
+    @quote = Post.create(valid_attributes.merge(:content => "quote"))
+    @number2 = Post.create(valid_attributes.merge(:user_id => 2))
+    @old = Post.create(valid_attributes.merge(:published_at => 1.year.ago))
+  end
+  
+  teardown do
+    ActiveRecord::Base.connection.tables.each do |table|
+      ActiveRecord::Base.connection.drop_table(table)
+    end
+  end
+  
+end

data/test/schema.rb

@@ -0,0 +1,48 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => "test.sqlite3")
+
+def setup_db
+  
+    ActiveRecord::Base.connection.tables.each do |table|
+      ActiveRecord::Base.connection.drop_table(table)
+    end
+    
+  ActiveRecord::Schema.define(:version => 1) do
+
+     create_table :posts do |t|
+        t.string :body
+        t.string :title
+        t.text :content
+        t.integer :user_id
+        t.datetime :published_at
+        t.timestamps
+      end
+
+      create_table :users do |t|
+        t.timestamps
+      end
+      
+      create_table :comments do |t|
+        t.text :subject
+        t.text :description
+        t.integer :post_id
+        t.timestamps
+      end
+      
+  end
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :user
+  has_many :comments
+end
+
+class User < ActiveRecord::Base
+  has_many :posts
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+end
+

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'test/unit'
+require 'active_support'

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: relata
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Anderson Leite, Guilherme Silveira
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-22 00:00:00 -02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: anderson.leite@caelum.com.br
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- Gemfile
+- init.rb
+- install.rb
+- MIT-LICENSE
+- Rakefile
+- README.markdown
+- test.sqlite3
+- uninstall.rb
+- lib/filtered_relation.rb
+- lib/relata/dsl/conditions.rb
+- lib/relata/dsl/constraints.rb
+- lib/relata/dsl/custom_relation.rb
+- lib/relata/dsl/field_search.rb
+- lib/relata/dsl/missed_builder.rb
+- lib/relata/dsl/querys/fields.rb
+- lib/relata/dsl/querys/multiple.rb
+- lib/relata/dsl/querys/simple.rb
+- lib/relata/dsl.rb
+- lib/relata/filter.rb
+- lib/relata/related_query_methods.rb
+- test/dsl_test.rb
+- test/filtered_relation_test.rb
+- test/schema.rb
+- test/test.sqlite3
+- test/test_helper.rb
+has_rdoc: false
+homepage: http://github.com/caelum/relata
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Helps poking around with relationships when using ARel
+test_files: []
+