Relata 0.0.2 → 0.0.3

data/Rakefile

@@ -27,7 +27,7 @@ PKG_FILES = FileList[ '[a-zA-Z]*', 'generators/**/*', 'lib/**/*', 'rails/**/*',
 
 spec = Gem::Specification.new do |s|
    s.name = "Relata"  
-   s.version = "0.0.2"  
+   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"  

data/init.rb

@@ -4,4 +4,4 @@ require 'ruby-debug'
 require 'active_record'
 require "active_support"
 
-require "filtered_relation"
+require "relata"

data/lib/relata.rb

@@ -0,0 +1,3 @@
+module Relata
+  require 'relata/filter'
+end

data/lib/relata/dsl.rb

@@ -0,0 +1,42 @@
+# 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'
+require 'relata/dsl/querys/belongs'
+
+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/dsl/conditions.rb

@@ -0,0 +1,65 @@
+# = Conditions
+# A custom set of conditions that can be applied
+# to a query
+module Relata::Dsl::Conditions
+
+  # Return all objects whith exactly X associated objects
+  #  Post.where(:comments).count.eq(2)
+  def eq(value)
+    add_filter("= #{value}")
+  end
+
+  # Return all objects whith more or exactly X associated objects
+  #  Post.where(:comments).count.ge(2)
+  def ge(value)
+    add_filter(">= #{value}")
+  end
+
+  # Return all objects whith more or exactly X associated objects
+  #  Post.where(:comments).count.greater_or_equals(2)
+  def greater_or_equals(value)
+    ge(value)
+  end
+  
+  # Return all objects whith more than X associated objects
+  #  Post.where(:comments).count.gt(2)
+  def gt(value)
+    add_filter("> #{value}")
+  end
+
+  # Return all objects whith more than X associated objects
+  # Alias for "gt"
+  #  Post.where(:comments).count.greater_than(2)
+  def greater_than(value)
+    gt(value)
+  end
+
+  # Return all objects whith less or equals X associated objects
+  #  Post.where(:comments).count.le(2)
+  def le(value)
+    add_filter("<= #{value}")
+  end
+
+  # Return all objects whith less than X associated objects
+  #  Post.where(:comments).count.lt(2)
+  def lt(value)
+    add_filter("< #{value}")
+  end
+
+  # Return all objects whith less than X associated object
+  # Alias for "lt"
+  #  Post.where(:comments).count.lesser_than(2)
+  def lesser_than(value)
+    lt value
+  end
+
+  # Whether this relation has at least one element.
+  #  Post.where(:comments).exists?
+  def exists?
+    if @relation_search.nil?
+      count.exists?
+    else
+      add_filter("> 0")
+    end
+  end  
+end

data/lib/{filtered_relation → relata}/dsl/constraints.rb

@@ -1,16 +1,15 @@
-module Constraints
+# = Constraints
+# A custom set of constraints that can be applied
+# to a query
+module Relata::Dsl::Constraints
   
+  # Return all objects which fields by size
+  #  Post.where { body.length < 22 }
   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"
@@ -18,9 +17,17 @@ module Constraints
     self
   end
 
+  # Return all objects which match with parameter
+  #  Post.where(:body).like?("%caelum%")
   def like?(value)
     query.where("#{@current_field} like ?", [value])
   end
+ 
+  # Return all objects whith nil value fields
+  #  Post.where(:body).is_null
+  def is_null
+    query.where("#{@current_field} is NULL")
+  end
   
   # def between(first, second)
   #   @relation_search = SimpleRangeCondition
@@ -29,6 +36,12 @@ module Constraints
   #   # add_filter("> #{first}").add_filter("< #{second}")
   # end
   
+  class LengthManager
+    def self.condition(field, *args)
+      "len(field)"
+    end
+  end
+  
   class SimpleCondition
     def self.condition(field, *args)
       "#{field}"

data/lib/relata/dsl/custom_relation.rb

@@ -0,0 +1,44 @@
+# 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      
+    elsif relates_belongs_to?
+      self.extend BelongsToQuery
+      self.extend ModelFields            
+    else
+      self.extend SimpleQuery
+    end
+    
+    self
+  end
+
+  def relates_to_many?
+    @record.reflect_on_all_associations.each do |r|
+      if r.name.to_sym.eql? @current_field.to_sym 
+        return true if r.macro.to_s.eql? "has_many"
+      end  
+    end  
+    false
+  end
+  
+  def relates_belongs_to?
+    @record.reflect_on_all_associations.each do |r|
+      if r.name.to_sym.eql? @current_field.to_sym 
+        return true if r.macro.to_s.eql? "belongs_to"
+      end  
+    end  
+    false
+  end
+
+end

data/lib/relata/dsl/field_search.rb

@@ -0,0 +1,111 @@
+# = Field Search
+# a relation search in a specific field
+class Relata::Dsl::FieldSearch
+  
+  def initialize(rel, field)
+    @rel = rel
+    @field = field
+  end
+
+  # Exactly number of relation or field value
+  #  Post.where { body == "CaelumObjects training and inovation" }
+  #  Post.where { comments == 2 }
+  def ==(value)
+    @rel.where("#{@field} == ?", value)
+  end
+
+  # All records with different field value
+  #  Post.where { comments == 2 }
+  def !=(value)
+    @rel.where("#{@field} <> ?", value)
+  end
+
+  # All records with higher or equal number of relations
+  #  Post.where { comments >= 2 }
+  def >=(value)
+    @rel.where("#{@field} >= ?", value)
+  end
+  
+  # All records with less or equal number of relations
+  #  Post.where { comments <= 2 }  
+  def <=(value)
+    @rel.where("#{@field} <= ?", value)
+  end
+
+  # All records with higher number of relations
+  #  Post.where { comments > 2 }    
+  def >(value)
+    @rel.where("#{@field} > ?", value)
+  end
+
+  # All records with lesser number of relations
+  #  Post.where { comments < 2 }      
+  def <(value)
+    @rel.where("#{@field} < ?", value)
+  end
+  
+  # Find records by field value
+  #  Post.where(:body).like?("%caelum%")    
+  def like?(value)
+    @rel.where(@field).like?(value)
+  end
+  
+  # Find record with date between 
+  #  Post.where { published_at.between(2.years.ago, 6.months.ago) }
+  def between(first, second)
+    @rel.where("#{@field} > ? and #{@field} < ?", first, second)
+  end
+
+  # Find records by size
+  #  Post.where { body.length < 22 }  
+  def length
+    @field = "length(#{@field})"
+    self
+  end
+
+  # Your custom relation
+  #  Post.where { body "like ?", "%lum%" }
+  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/belongs.rb

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

data/lib/{filtered_relation → relata}/dsl/querys/fields.rb

@@ -1,13 +1,13 @@
 module ModelFields
   
   def self.extended(base)
-    
+    @fields = []    
     base.reflect_on_all_associations.each do |r|
-      @fields = r.klass.columns.map do |c|
-        c.name if [:string, :text].include? c.type
+      r.klass.columns.each do |c|
+        @fields << c.name if [:string, :text].include? c.type
       end  
     end  
-    
+
     @fields.each do |field|
       include_method field if field != nil
     end  
@@ -17,6 +17,11 @@ module ModelFields
   private
   def self.include_method(field)
     define_method field do 
+            
+      @record.reflect_on_all_associations.each do |r|
+        @current_field = @current_field.to_s.pluralize if r.macro.to_s.eql? "belongs_to"
+      end  
+
       @current_field = "#{@current_field}.#{field}"
       self
     end

data/lib/{filtered_relation → relata}/filter.rb

@@ -1,6 +1,26 @@
 require 'filtered_relation/related_query_methods'
 ActiveRecord::Base.send :include, RelatedQueryMethods
 
+
+# = Filtered Relation
+# 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 with DSL.
+
+#  posts = Post.filtered_relation(:comments => true).where(:user_id => 4).limit(3).order("id ASC") 



+
+#  posts.each do |post| 

+#  # records
+#  end 

 module FilteredRelation
 
   class ::ActiveRecord::Base

data/test/dsl_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__)) + "/test_helper"
 require 'schema'
-require 'filtered_relation/dsl'
+require 'relata/dsl'
 
 class DSLTest < ActiveSupport::TestCase
   
@@ -14,17 +14,17 @@ class DSLTest < ActiveSupport::TestCase
     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 < 22 }
-  #   assert_equal @guilherme, 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]) 
@@ -38,7 +38,7 @@ class DSLTest < ActiveSupport::TestCase
     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
@@ -61,64 +61,121 @@ class DSLTest < ActiveSupport::TestCase
   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)
+  
+    posts = Post.where(:comments).count.ge(2).all
+    assert_equal 2, posts.size
     assert_equal @caelum, posts[0]
     assert_equal @guilherme, posts[1]
-    assert_equal 2, posts.size
   end
    
-  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
-
+  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
-
+   
   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
+  
+  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
+    posts = Post.where { body == "CaelumObjects training and inovation" }
+    assert_equal @caelum, posts[0]
+    assert_equal 1, posts.size
+  end
+
+  test "supports != with simple field" do
+    posts = Post.where { body != "diff" }
+    assert_equal @caelum, posts[0]
+    assert_equal @guilherme, posts[1]    
     assert_equal 2, posts.size
   end
 
-  test "exists posts using range expectations" do
+  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 "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%")
+  test "accepts any custom condition" do
+    posts = Post.where { body "like ?", "%lum%" }
     assert_equal @caelum, posts[0]
     assert_equal 1, posts.size
   end
-  
-  # test "exists posts aaaaaaaaaaaaa" do
-  #   @caelum.update_attributes :published_at => 1.year.ago
-  #   
-  #   posts = Post.where { 
-  #     published_at.between(2.years.ago, 6.months.ago)
-  #     name.like?
-  #      }
+
+  test "give records with nil fields" do
+    @caelum.update_attributes :body => nil
+    posts = Post.where(:body).is_null
+    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
 
-  # def pending
-    # support .all, .first, and so on
-    # posts = Post.where { comments.description.like?("%dsl test%") }
-    # posts = posts.and(:authors).count.lt(3)
     # Author.where(:posts).comments.count.gt(2)
-   # end
-
+    
 end

data/test/filtered_relation_test.rb

@@ -1,55 +1,55 @@
 require File.expand_path(File.dirname(__FILE__)) + "/test_helper"
 
-require 'filtered_relation/filter'
+require 'relata/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 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 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 
     
-    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
       
-      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 = {

data/test/relation_dsl_test.rb

@@ -0,0 +1,57 @@
+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 "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 "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 "all post which commits has some subject and another has_many relation" do
+      reader = Reader.create :name => "anderson"
+      comment = Comment.create :subject => "dsl subject"
+      @caelum.update_attributes :comments => [comment], :readers => [reader]
+      posts = Post.where(:comments).subject.like?("%dsl subject%")
+      assert_equal @caelum, posts[0]
+      assert_equal 1, posts.size
+    end
+
+    test "exists posts for a specific user name" do
+      user = User.create :name => "anderson"
+      @caelum.update_attributes(:user => user) 
+      posts = Post.where(:user).name.like?("anderson")
+      assert_equal @caelum, posts[0]
+      assert_equal 1, posts.size
+    end
+
+    test "exists posts for a specific user title" do
+      user = User.create :title => "programmer"
+      @caelum.update_attributes(:user => user) 
+      posts = Post.where(:user).title.like?("programmer")
+      assert_equal @caelum, posts[0]
+      assert_equal 1, posts.size
+    end
+
+
+end  

data/test/schema.rb

@@ -20,6 +20,8 @@ def setup_db
       end
 
       create_table :users do |t|
+        t.string :name
+        t.text :title        
         t.timestamps
       end
       
@@ -29,6 +31,13 @@ def setup_db
         t.integer :post_id
         t.timestamps
       end
+
+      create_table :readers do |t|
+        t.text :name
+        t.integer :post_id
+        t.timestamps
+      end
+
       
   end
 end
@@ -36,6 +45,7 @@ end
 class Post < ActiveRecord::Base
   belongs_to :user
   has_many :comments
+  has_many :readers
 end
 
 class User < ActiveRecord::Base
@@ -46,3 +56,7 @@ class Comment < ActiveRecord::Base
   belongs_to :post
 end
 
+class Reader < ActiveRecord::Base
+  belongs_to :post
+end
+

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Anderson Leite, Guilherme Silveira
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-04 00:00:00 -03:00
+date: 2010-10-05 00:00:00 -03:00
 default_executable: 
 dependencies: []
 
@@ -35,17 +35,22 @@ files:
 - README.markdown
 - test.sqlite3
 - uninstall.rb
-- lib/filtered_relation/dsl/conditions.rb
-- lib/filtered_relation/dsl/constraints.rb
-- lib/filtered_relation/dsl/querys/fields.rb
-- lib/filtered_relation/dsl/querys/multiple.rb
-- lib/filtered_relation/dsl/querys/simple.rb
-- lib/filtered_relation/dsl.rb
-- lib/filtered_relation/filter.rb
-- lib/filtered_relation/related_query_methods.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/belongs.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
+- lib/relata.rb
 - test/dsl_test.rb
 - test/filtered_relation_test.rb
+- test/relation_dsl_test.rb
 - test/schema.rb
 - test/test_helper.rb
 has_rdoc: true

data/lib/filtered_relation.rb

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

data/lib/filtered_relation/dsl.rb

@@ -1,109 +0,0 @@
-require 'filtered_relation/dsl/conditions'
-require 'filtered_relation/dsl/constraints'
-require 'filtered_relation/dsl/querys/multiple'
-require 'filtered_relation/dsl/querys/simple'
-require 'filtered_relation/dsl/querys/fields'
-
-# in case you did not require the entire filtered_relation plugin
-module FilteredRelation
-  module Dsl
-  end
-end
-
-# defines helper methods to deal with custom relation
-module FilteredRelation::Dsl::CustomRelation
-  include Conditions
-  include 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
-
-  private
-  
-  def relates_to_many?
-    @record.reflect_on_association @current_field.to_sym
-  end
-
-end
-
-# a relation search in a specific field
-class FilteredRelation::Dsl::FieldSearch
-  
-  def initialize(rel, field)
-    @rel = rel
-    @field = field
-  end
-
-  def >=(value)
-    @rel.where(@field).count.ge(value)
-  end
-  
-  def like?(value)
-    @rel.where(@field).like?(value)
-  end
-  
-  def exists?
-    @rel.where(@field).exists?
-  end
-  
-  def between(first, second)
-    @rel.where("#{@field} > ? and #{@field} < ?", first, second)
-  end
-
-end
-
-# a builder ready to collect which field you want to search
-class FilteredRelation::Dsl::MissedBuilder
-  
-  def initialize(rel)
-    @rel = rel
-  end
-  
-  def method_missing(field, *args)
-    if args.size != 0
-      raise "Unable to setup a parameter with args: #{field} and #{args}"
-    end
-    FilteredRelation::Dsl::FieldSearch.new(@rel, field)
-  end
-  
-end
-
-module FilteredRelation::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
-      FilteredRelation::Dsl::MissedBuilder.new(self).instance_eval(&block)
-    elsif args.size==1 && args[0].is_a?(Symbol)
-      relation = scoped
-      relation.extend FilteredRelation::Dsl::CustomRelation
-      relation.using(self, args[0])
-    else
-      super(*args, &block)
-    end
-  end
-end
-
-class ActiveRecord::Relation
-  include FilteredRelation::Dsl::Relation
-end

data/lib/filtered_relation/dsl/conditions.rb

@@ -1,36 +0,0 @@
-# A custom set of conditions that can be applied
-# to a query
-module Conditions
-  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 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