yaml_conditions 0.0.0.1 → 0.0.0.2

data/README.rdoc

@@ -24,11 +24,11 @@ Below I summarized some samples so you can see how I use it.
 
   Company.find(:first, :yaml_conditions => { :data => {  { :street => '5551 LEOPARD ST' }, :status => :active }, :conditions => [ 'branches_counter > ?', 3] )
 
-As you can see from the last sample, both yaml_conditions and conditions will be merged in order to find the expected results.
+As you can see on this sample, both yaml_conditions and conditions will be merged in order to find the expected results.
 
   Company.find(:last, :yaml_conditions => { :data => { :user => { :last_name => 'Marcelo', :address => { :city => Yaml::NotSerializedField.new('Rio Negro') } } } })
 
-On this last sample, the city attribute can be traversed on memory but it is not saved on the serialized field (i.e. handler), so we want to indicate that to avoid building an invalid SQL.
+On this last sample, the city attribute will be used to filter the objects on memory but it is not used to build the SQL query. This can be handy if we want to filter based on a field (i.e. city) that is not serialized within the yaml object within the database, but can be traversed through messaging between objects.
 
 BTW: All methods ActiveRecord::Base#{last, first, all} rely on ActiveRecord::Base#find, so we can use yaml_conditions with these methods too. As an example:
 Company.all(:yaml_conditions => { :data => { :address => { :street => '5551 LEAOPARD ST' } } }) behaves the same way as the first sample explained below.
@@ -43,11 +43,11 @@ So, I added some custom magic for filtering Delayed::Job objects, like this:
 
   Delayed::Job.first(:yaml_conditions => { :handler => { :args => [ { :user => { :last_name => 'Marcelo', :address => { :city => 'Rio Negro' } } } ] } })
 
-As you probably realize, '*' is interpreted (for Delayed::Job instances) as a wildcard.
+As you probably realize, '*' is interpreted as a wildcard.
 
 == Installation
 
-  $ ruby script/plugin install git://github.com/marklazz/yaml_conditions.git)
+  $ ruby script/plugin install git://github.com/marklazz/yaml_conditions.git
 
 OR install it as a gem
 

data/Rakefile

@@ -3,7 +3,7 @@ require 'echoe'
 
 # PACKAGING ============================================================
 
-Echoe.new('yaml_conditions', '0.0.0.1') do |p|
+Echoe.new('yaml_conditions', '0.0.0.2') do |p|
   p.description = ''
   p.url = 'http://github.com/marklazz/yaml_conditions'
   p.author = 'Marcelo Giorgi'

data/TESTS.rdoc

@@ -1,4 +1,4 @@
-Before running the tests you should create a user yaml_conditions for mysql (and for postgresql too if you want to run them there).
+Before running the tests, you must create a user called yaml_conditions (with no password) for mysql (and/or postgresql).
 
 Then to run the suite you should be able to do:
 
@@ -7,6 +7,7 @@ rake spec (which will run both suites for mysql and postgres)
 Or run them individually:
 
 rake mysql:spec
+
 rake postgres:spec
 
 Enjoy!

data/lib/orms/active_record/version2/delayed_job.rb

@@ -14,13 +14,14 @@ module Orms
 
         CLASS_STRING_FORMAT = /^CLASS\:([A-Z][\w\:]+)$/
         AR_STRING_FORMAT    = /^AR\:([A-Z][\w\:]+)\:(\d+)$/
+        LOAD_AR_STRING_FORMAT    = /^LOAD;([A-Z][\w\:]+);(\d+)$/
 
         def __delayed_job_ar_to_string_(obj)
-          "AR:#{obj.class}:#{obj.id}"
+          Delayed::PerformableMethod.new(obj, :to_s, []).object
         end
 
         def __delayed_job_class_to_string_(obj)
-          "CLASS:#{obj.name}"
+          Delayed::PerformableMethod.new(obj, :to_s, []).object
         end
 
         def __serialize__to_yaml_value__(arg)
@@ -35,6 +36,7 @@ module Orms
           case arg
             when CLASS_STRING_FORMAT then $1.constantize
             when AR_STRING_FORMAT    then $1.constantize.find($2)
+            when LOAD_AR_STRING_FORMAT then $1.constantize.find($2)
             else super(arg)
           end
         end

data/spec/cases/orms/active_record/version_2_spec.rb

@@ -144,10 +144,11 @@ describe Orms::ActiveRecordVersion2 do
         struct_instance = @struct.new(:new_email, @user.to_yaml, 'foo@gmail.com', 4, 0.005)
         @job = Job.create(:name => 'job1', :data => struct_instance)
         @yaml_conditions = {}
+        @selector = :first
         @conditions = {}
       end
 
-      subject { Job.find(:first, :yaml_conditions => @yaml_conditions, :conditions => @conditions) }
+      subject { Job.find(@selector, :yaml_conditions => @yaml_conditions, :conditions => @conditions) }
 
       context 'filter for the proper class but wrong float' do
         before do
@@ -281,13 +282,13 @@ describe Orms::ActiveRecordVersion2 do
         before do
           period = Period.create(:year => 2000)
           user_data = UserData.create(:social_number => 123, :title => 'Computer Engineer', :period => period)
-          user = User.create(:name => 'marcelo', :details => user_data)
-          @complex_job = Job.create(:name => 'job1', :data => { :owner => user })
+          user = User.create(:name => 'marklazz', :details => user_data)
+          @complex_job = Job.create(:name => 'cpmplex_job', :data => { :owner => user })
         end
 
         context 'query using correct social_number' do
           before do
-            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marcelo', :details => { :social_number => 123 } } } }
+            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marklazz', :details => { :social_number => 123 } } } }
           end
 
           it { should == @complex_job }
@@ -295,7 +296,7 @@ describe Orms::ActiveRecordVersion2 do
 
         context 'query using correct social_number' do
           before do
-            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marcelo', :details => { :social_number => 124 } } } }
+            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marklazz', :details => { :social_number => 124 } } } }
           end
 
           it { should be_nil }
@@ -303,7 +304,7 @@ describe Orms::ActiveRecordVersion2 do
 
         context 'query using the UserData class' do
           before do
-            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marcelo', :details => { :class => UserData } } } }
+            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marklazz', :details => { :class => UserData } } } }
           end
 
           it { should == @complex_job }
@@ -311,7 +312,7 @@ describe Orms::ActiveRecordVersion2 do
 
         context 'query using the UserData class and title and social_number' do
           before do
-            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marcelo', :details => { :class => UserData, :title =>  'Computer Engineer' } } } }
+            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marklazz', :details => { :class => UserData, :title =>  'Computer Engineer' } } } }
           end
 
           it { should == @complex_job }
@@ -319,7 +320,7 @@ describe Orms::ActiveRecordVersion2 do
 
         context 'query using the UserData class, social_number and wrong title' do
           before do
-            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marcelo', :details => { :class => UserData, :title =>  'Teacher' } } } }
+            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marklazz', :details => { :class => UserData, :title =>  'Teacher' } } } }
           end
 
           it { should be_nil }
@@ -327,15 +328,85 @@ describe Orms::ActiveRecordVersion2 do
 
         context 'query using the UserData class and title and social_number' do
           before do
-            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marcelo', :details => { :class => UserData, :title =>  'Computer Engineer', :period => { :class => Period, :year => 2000 } } } } }
+            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marklazz', :details => { :class => UserData, :title =>  'Computer Engineer', :period => { :class => Period, :year => 2000 } } } } }
           end
 
           it { should == @complex_job }
         end
 
-        context 'query using NotSerializedField' do
+        context "query using wrong value on a NotSerializedField" do
+          before do
+            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marklazz', :details => { :class => UserData, :title =>  'Computer Engineer', :period => { :class => Period, :year => Yaml::NotSerializedField.new(1542) } } } } }
+          end
+
+          it { should be_nil }
+
+          it 'should not include the NotSerializedField in the generated sql' do
+            Job.__build_yaml_conditions__(@yaml_conditions).should_not include('city')
+            Job.__build_yaml_conditions__(@yaml_conditions).should_not include('1542')
+          end
+
+          it 'should include the standard fields in the generated sql' do
+            Job.__build_yaml_conditions__(@yaml_conditions).should include('name')
+            Job.__build_yaml_conditions__(@yaml_conditions).should include('marklazz')
+          end
+        end
+
+        context "query using NotSerializedField for an attribute not present on yaml's column" do
+          before do
+            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marklazz', :details => { :class => UserData, :title =>  'Computer Engineer', :period => { :class => Period, :year => Yaml::NotSerializedField.new(2000) } } } } }
+          end
+
+          it { should == @complex_job }
+
+          it 'should not include the NotSerializedField in the generated sql' do
+            Job.__build_yaml_conditions__(@yaml_conditions).should_not include('2000')
+            Job.__build_yaml_conditions__(@yaml_conditions).should_not include('city')
+          end
+
+          it 'should include the standard fields in the generated sql' do
+            Job.__build_yaml_conditions__(@yaml_conditions).should include('marklazz')
+            Job.__build_yaml_conditions__(@yaml_conditions).should include('name')
+          end
+        end
+
+        context "query using NotSerializedField for an attribute present on yaml's column" do
+          before do
+            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => Yaml::NotSerializedField.new('marklazz'), :details => { :class => UserData, :title =>  'Computer Engineer' } } } }
+          end
+
+          it { should == @complex_job }
+
+          it 'should not include the NotSerializedField in the generated sql' do
+            Job.__build_yaml_conditions__(@yaml_conditions).should_not include('name')
+            Job.__build_yaml_conditions__(@yaml_conditions).should_not include('marklazz')
+          end
+        end
+
+        context "query using wildcard and on nested structure" do
+          before do
+            2.times do
+              user_data = UserData.create(:social_number => rand(100), :title => 'Computer Engineer')
+              user = User.create(:name => "marklazz_#{rand(100)}", :details => user_data)
+              job = Job.create(:name => "cpmplex_job_#{rand(100)}", :data => { :owner => user })
+            end
+            user_data = UserData.create(:social_number => rand(100), :title => 'Teacher')
+            user = User.create(:name => "marklazz_#{rand(100)}", :details => user_data)
+            job = Job.create(:name => "cpmplex_job_#{rand(100)}", :data => { :owner => user })
+            @selector = :all
+            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => '*', :details => { :class => UserData, :title =>  'Computer Engineer' } } } }
+          end
+
+          it 'should have a total of 5 job' do
+            Job.count.should == 5
+          end
+
+          its(:length) { should == 3 }
+        end
+
+        context "query using wildcard and NotSerializedField" do
           before do
-            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marcelo', :details => { :class => UserData, :title =>  'Computer Engineer', :period => { :class => Period, :year => Yaml::NotSerializedField.new(2000) } } } } }
+            @yaml_conditions = { :data => { :class => Hash, :owner => { :name => 'marklazz', :details => { :class => UserData, :title =>  'Computer Engineer', :period => { :class => Period, :year => '*' } } } } }
           end
 
           it { should == @complex_job }

data/yaml_conditions.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{yaml_conditions}
-  s.version = "0.0.0.1"
+  s.version = "0.0.0.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Marcelo Giorgi"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: yaml_conditions
 version: !ruby/object:Gem::Version 
-  hash: 77
+  hash: 75
   prerelease: false
   segments: 
   - 0
   - 0
   - 0
-  - 1
-  version: 0.0.0.1
+  - 2
+  version: 0.0.0.2
 platform: ruby
 authors: 
 - Marcelo Giorgi