delayed_job_shallow_mongoid 0.5.0 → 0.5.1

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+0.5.1
+-----
+
+* [#4](https://github.com/joeyAghion/delayed_job_shallow_mongoid/pull/4): Fix: `const_missing: uninitialized constant Delayed::DelayMail (NameError)` with Rails - [@dblock](http://github.com/dblock).
+* [#4](https://github.com/joeyAghion/delayed_job_shallow_mongoid/pull/4): Fix: do not run job when a Mongoid instance is not found within delayed_job arguments and `Mongoid.raise_not_found_error` is set to `false` - [@dblock](http://github.com/dblock).
+
 0.5.0
 -----
 

data/delayed_job_shallow_mongoid.gemspec

@@ -1,11 +1,14 @@
 # -*- encoding: utf-8 -*-
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'delayed/shallow_mongoid/version'
+
 Gem::Specification.new do |s|
   s.name = "delayed_job_shallow_mongoid"
-  s.version = "0.5.0"
+  s.version = Delayed::ShallowMongoid::VERSION
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Joey Aghion"]
-  s.date = "2012-11-19"
+  s.authors = ["Joey Aghion", "Daniel Doubrovkine"]
   s.description = "When the object or arg to a delayed_job is a Mongoid document, store only a small stub of the object instead of the full serialization."
   s.email = "joey@aghion.com"
   s.extra_rdoc_files = [
@@ -20,50 +23,27 @@ Gem::Specification.new do |s|
     "LICENSE.txt",
     "README.md",
     "Rakefile",
-    "VERSION",
     "delayed_job_shallow_mongoid.gemspec",
-    "lib/delayed/performable_mailer.rb",
     "lib/delayed/shallow_mongoid.rb",
     "lib/delayed/shallow_mongoid/document_stub.rb",
     "lib/delayed/shallow_mongoid/performable_mailer.rb",
     "lib/delayed/shallow_mongoid/performable_method.rb",
-    "lib/delayed_job_shallow_mongoid.rb",
-    "spec/delayed_job_shallow_mongoid_spec.rb",
-    "spec/spec_helper.rb"
+    "lib/delayed/shallow_mongoid/version.rb",
+    "lib/delayed_job_shallow_mongoid.rb"
   ]
   s.homepage = "http://github.com/joeyAghion/delayed_job_shallow_mongoid"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.24"
   s.summary = "More efficient Mongoid document serialization for delayed_job."
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<delayed_job>, ["~> 3.0"])
-      s.add_runtime_dependency(%q<mongoid>, ["~> 3.0"])
-      s.add_development_dependency(%q<actionmailer>, [">= 0"])
-      s.add_development_dependency(%q<shoulda>, [">= 0"])
-      s.add_development_dependency(%q<rake>, ["~> 10.0"])
-      s.add_development_dependency(%q<rspec>, [">= 0"])
-      s.add_development_dependency(%q<ruby-debug19>, [">= 0"])
-    else
-      s.add_dependency(%q<delayed_job>, ["~> 3.0"])
-      s.add_dependency(%q<mongoid>, ["~> 3.0"])
-      s.add_dependency(%q<actionmailer>, [">= 0"])
-      s.add_dependency(%q<shoulda>, [">= 0"])
-      s.add_dependency(%q<rspec>, [">= 0"])
-      s.add_dependency(%q<ruby-debug19>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<delayed_job>, ["~> 3.0"])
-    s.add_dependency(%q<mongoid>, ["~> 3.0"])
-    s.add_dependency(%q<actionmailer>, [">= 0"])
-    s.add_dependency(%q<shoulda>, [">= 0"])
-    s.add_dependency(%q<rake >, ["~> 10.0"])
-    s.add_dependency(%q<rspec>, [">= 0"])
-    s.add_dependency(%q<ruby-debug19>, [">= 0"])
-  end
+  s.specification_version = 3
+  s.add_runtime_dependency(%q<delayed_job>, ["~> 3.0"])
+  s.add_runtime_dependency(%q<delayed_job_mongoid>, ["~> 2.0"])
+  s.add_runtime_dependency(%q<mongoid>, ["~> 3.0"])
+  s.add_development_dependency(%q<actionmailer>, [">= 0"])
+  s.add_development_dependency(%q<shoulda>, [">= 0"])
+  s.add_development_dependency(%q<rake>, ["~> 10.0"])
+  s.add_development_dependency(%q<rspec>, [">= 0"])
+  s.add_development_dependency(%q<ruby-debug19>, [">= 0"])
 end
 

data/lib/delayed/shallow_mongoid.rb

@@ -1,5 +1,11 @@
 module Delayed
   module ShallowMongoid
+
+    module Errors
+      class DocumentNotFound < StandardError
+      end
+    end
+
     def self.dump(arg)
       return arg unless arg.is_a?(::Mongoid::Document) && arg.persisted?
       return arg if arg._updates.any? && !Delayed::Worker.delay_jobs
@@ -9,16 +15,22 @@ module Delayed
         ShallowMongoid::DocumentStub.new(arg.class, arg._id.to_s)
       end
     end
-  
+
     def self.load(arg)
       return arg unless arg.is_a?(ShallowMongoid::DocumentStub)
-      result = arg.klass.find(arg.id)
+      begin
+        result = arg.klass.find(arg.id)
+        raise Delayed::ShallowMongoid::Errors::DocumentNotFound unless result
+      rescue Mongoid::Errors::DocumentNotFound
+        raise Delayed::ShallowMongoid::Errors::DocumentNotFound
+      end
       (arg.selector || []).each do |message|
         result = result.send(*message)
       end
+      raise Delayed::ShallowMongoid::Errors::DocumentNotFound unless result
       result
     end
-  
+
     # The chain of relations allowing us to locate an embedded document.
     # E.g., ['images', ['find', '4eef..678'], 'width']
     def self.selector_from(doc)

data/lib/delayed/shallow_mongoid/performable_mailer.rb

@@ -1,13 +1,11 @@
 module Delayed
-  class PerformableMailer
+  class PerformableMailer < PerformableMethod
     def perform
-      begin
-        klass = ShallowMongoid.load(object)
-        delayed_arguments = *args.map{|a| ShallowMongoid.load(a) }
-      rescue Mongoid::Errors::DocumentNotFound
-        return true  # do nothing if document has been removed
-      end
+      klass = ShallowMongoid.load(object)
+      delayed_arguments = *args.map{|a| ShallowMongoid.load(a) }
       klass.send(method_name, *delayed_arguments).deliver
+    rescue Delayed::ShallowMongoid::Errors::DocumentNotFound
+      return true  # do nothing if document has been removed
     end
   end
 end

data/lib/delayed/shallow_mongoid/performable_method.rb

@@ -11,14 +11,11 @@ module Delayed
     end
 
     def perform
-      begin
-        klass = ShallowMongoid.load(object)
-        return true unless klass
-        delayed_arguments = *args.map{|a| ShallowMongoid.load(a) }
-      rescue Mongoid::Errors::DocumentNotFound
-        return true  # do nothing if document has been removed
-      end
+      klass = ShallowMongoid.load(object)
+      delayed_arguments = *args.map{|a| ShallowMongoid.load(a) }
       klass.send(method_name, *delayed_arguments)
+    rescue Delayed::ShallowMongoid::Errors::DocumentNotFound
+      return true  # do nothing if document has been removed
     end
 
     def display_name

data/lib/delayed/shallow_mongoid/version.rb

@@ -0,0 +1,5 @@
+module Delayed
+  module ShallowMongoid
+    VERSION = "0.5.1"
+  end
+end

data/lib/delayed_job_shallow_mongoid.rb

@@ -1,5 +1,6 @@
 require 'delayed_job'
 require File.dirname(__FILE__) + '/delayed/shallow_mongoid'
+require File.dirname(__FILE__) + '/delayed/shallow_mongoid/version'
 require File.dirname(__FILE__) + '/delayed/shallow_mongoid/document_stub'
 require File.dirname(__FILE__) + '/delayed/shallow_mongoid/performable_method'
 require File.dirname(__FILE__) + '/delayed/shallow_mongoid/performable_mailer'

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: delayed_job_shallow_mongoid
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
   prerelease: 
 platform: ruby
 authors:
 - Joey Aghion
+- Daniel Doubrovkine
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-19 00:00:00.000000000 Z
+date: 2012-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: delayed_job
@@ -27,6 +28,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: delayed_job_mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: mongoid
   requirement: !ruby/object:Gem::Requirement
@@ -139,16 +156,13 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- VERSION
 - delayed_job_shallow_mongoid.gemspec
-- lib/delayed/performable_mailer.rb
 - lib/delayed/shallow_mongoid.rb
 - lib/delayed/shallow_mongoid/document_stub.rb
 - lib/delayed/shallow_mongoid/performable_mailer.rb
 - lib/delayed/shallow_mongoid/performable_method.rb
+- lib/delayed/shallow_mongoid/version.rb
 - lib/delayed_job_shallow_mongoid.rb
-- spec/delayed_job_shallow_mongoid_spec.rb
-- spec/spec_helper.rb
 homepage: http://github.com/joeyAghion/delayed_job_shallow_mongoid
 licenses:
 - MIT
@@ -164,13 +178,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2112816115078860276
+      hash: 480325997688566083
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 480325997688566083
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24

data/VERSION

@@ -1,2 +0,0 @@
-0.5.0
-

data/lib/delayed/performable_mailer.rb

@@ -1,7 +0,0 @@
-module Delayed
-  class PerformableMailer < PerformableMethod
-    def perform
-      ShallowMongoid.load(object).send(method_name, *args.map{|a| ShallowMongoid.load(a) }).deliver
-    end
-  end
-end

data/spec/delayed_job_shallow_mongoid_spec.rb

@@ -1,176 +0,0 @@
-require 'spec_helper'
-
-class GrandchildModel
-  include ::Mongoid::Document
-  embedded_in :child_model, :inverse_of => :grandchild_models
-end
-class ChildModel
-  include ::Mongoid::Document
-  embedded_in :test_model, :inverse_of => :child_models
-  embeds_many :grandchild_models
-end
-class TestModel
-  include ::Mongoid::Document
-  field :title
-  embeds_many :child_models
-end
-
-describe Delayed::ShallowMongoid::DocumentStub do
-  it "should have a klass" do
-    @shallow = Delayed::ShallowMongoid::DocumentStub.new(TestModel, 111)
-    @shallow.klass.should == TestModel
-  end
-  it "should have an id" do
-    @shallow = Delayed::ShallowMongoid::DocumentStub.new(TestModel, 111)
-    @shallow.id.should == 111
-  end
-  it "should have an optional selector" do
-    @shallow = Delayed::ShallowMongoid::DocumentStub.new(TestModel, 111)
-    @shallow.selector.should == nil
-  end
-  it "can have an actual selector" do
-    @shallow = Delayed::ShallowMongoid::DocumentStub.new(TestModel, 111, [:a, :b])
-    @shallow.selector.should == [:a, :b]
-  end
-end
-
-describe ::Delayed::PerformableMethod do
-  context "with an unsaved document" do
-    it "should not transform an unsaved document" do
-      @model = TestModel.new
-      method = ::Delayed::PerformableMethod.new(@model, :to_s, [])
-      method.object.should_not be_a_kind_of(Delayed::ShallowMongoid::DocumentStub)
-    end
-  end
-
-  context "with a saved document" do
-    before(:each) do
-      @model = TestModel.create #new(:_id => Moped::BSON::ObjectId.new)
-    end
-
-    context 'when saving job' do
-      context 'when jobs are run immediately' do
-        before { ::Delayed::Worker.delay_jobs = false }
-        after { ::Delayed::Worker.delay_jobs = true }
-        it "should not transform if there are pending changes and jobs are run immediately" do
-          @model.title = "updated"
-          method = ::Delayed::PerformableMethod.new(@model, :to_s, [])
-          method.object.should_not be_a_kind_of(Delayed::ShallowMongoid::DocumentStub)
-        end
-      end
-      it "should transform object into shallow version" do
-        method = ::Delayed::PerformableMethod.new(@model, :to_s, [])
-        method.object.should be_a_kind_of(Delayed::ShallowMongoid::DocumentStub)
-        method.object.id.should == @model._id.to_s
-      end
-      it "should transform arg into shallow version" do
-        method = ::Delayed::PerformableMethod.new('test', :lines, [@model])
-        method.args.first.should be_a_kind_of(Delayed::ShallowMongoid::DocumentStub)
-        method.args.first.id.should == @model._id.to_s
-      end
-      context "with an embedded document" do
-        before(:each) do
-          @child = ChildModel.new(:_id => Moped::BSON::ObjectId.new)
-          @model.child_models.push @child
-        end
-        after(:each) do
-          @method.object.should be_a_kind_of(Delayed::ShallowMongoid::DocumentStub)
-          @method.object.id.should == @model.id.to_s
-          @method.object.klass.should == @model.class
-        end
-        it "should store the selector" do
-          @method = ::Delayed::PerformableMethod.new(@child, :to_s, [])
-          @method.object.selector.should == ['child_models', ['find', @child._id.to_s]]
-        end
-        it "should store the deeply nested selector" do
-          @grandchild = GrandchildModel.new(:_id => Moped::BSON::ObjectId.new)
-          @model.child_models.first.grandchild_models.push @grandchild
-          @method = ::Delayed::PerformableMethod.new(@grandchild, :to_s, [])
-          @method.object.selector.should == ['child_models', ['find', @child._id.to_s], 'grandchild_models', ['find', @grandchild._id.to_s]]
-        end
-      end
-    end
-
-    context 'when running job' do
-      it "should look up document" do
-        method = ::Delayed::PerformableMethod.new(@model, :to_s, [])
-        TestModel.should_receive(:find).with(@model._id.to_s).and_return(@model)
-        method.perform
-      end
-      it "should do nothing if document not found" do
-        method = ::Delayed::PerformableMethod.new(@model, :to_s, [])
-        error = ::Mongoid::Errors::DocumentNotFound.new(TestModel, nil, [ @model.id ])
-        TestModel.should_receive(:find).with(@model._id.to_s).and_raise(error)
-        method.perform.should be_true
-      end
-      it "should do nothing if document find returned nil" do
-        method = ::Delayed::PerformableMethod.new(@model, :to_s, [])
-        @model.destroy
-        TestModel.should_receive(:find).with(@model._id.to_s).and_return(nil)
-        method.perform.should be_true
-      end
-      it "should find embedded document" do
-        child = ChildModel.new(:_id => Moped::BSON::ObjectId.new)
-        @model.child_models.push child
-        method = ::Delayed::PerformableMethod.new(child, :to_s, [])
-        TestModel.should_receive(:find).with(@model._id.to_s).and_return(@model)
-        method.perform
-      end
-    end
-
-    context "display_name" do
-      it "should return underlying class when a stub is being used" do
-        method = ::Delayed::PerformableMethod.new(@model, :to_s, [])
-        method.display_name.should == "TestModel[#{@model._id}]#to_s"
-      end
-      it "should return usual name when no stub is involved" do
-        method = ::Delayed::PerformableMethod.new(:test, :to_s, [])
-        method.display_name.should == "Symbol#to_s"
-      end
-      it "should include selector when document is embedded" do
-        child = ChildModel.new(:_id => Moped::BSON::ObjectId.new)
-        @model.child_models.push child
-        method = ::Delayed::PerformableMethod.new(child, :to_s, [])
-        method.display_name.should == "TestModel[#{@model._id}].child_models.find(\"#{child._id}\")#to_s"
-      end
-    end
-  end
-end
-
-describe ::Delayed::PerformableMailer do
-  context "successful mailer" do
-    before do
-      @model = TestModel.create
-      @email = mock('email', :deliver => true)
-      @mailer_class = mock('MailerClass', :signup => @email)
-      @mailer = ::Delayed::PerformableMailer.new(@mailer_class, :signup, [@model])
-    end
-    it "should call the method and #deliver on the mailer" do
-      TestModel.should_receive(:find).with(@model._id.to_s).and_return(@model)
-      @mailer_class.should_receive(:signup).with(@model)
-      @email.should_receive(:deliver)
-      @mailer.perform
-    end
-    it "should do nothing if an argument document is not found" do
-      error = ::Mongoid::Errors::DocumentNotFound.new(TestModel, nil, [ @model._id ])
-      TestModel.should_receive(:find).with(@model._id.to_s).and_raise(error)
-      @mailer.perform.should be_true
-    end
-  end
-  context "failing mailer from bad record" do
-    before do
-      @model = TestModel.create
-      error = ::Mongoid::Errors::DocumentNotFound.new(TestModel, nil, [ @model._id ])
-      @email = mock('email')
-      @email.stub(:deliver).and_raise(error)
-      @mailer_class = mock('MailerClass', :signup => @email)
-      @mailer = ::Delayed::PerformableMailer.new(@mailer_class, :signup, [@model])
-    end
-    it "should fail if an exception comes up" do
-      TestModel.stub(:find).with(@model._id.to_s).and_return(@model)
-      -> {
-        @mailer.perform
-      }.should raise_error(::Mongoid::Errors::DocumentNotFound)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,21 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-
-require 'mail'
-require 'action_mailer'
-require 'mongoid'
-require 'delayed_job_shallow_mongoid'
-
-Mongoid.configure do |config|
-  config.connect_to('delayed_job_shallow_mongoid_test')
-end
-
-RSpec.configure do |config|
-  config.before(:each) do
-    Mongoid.purge!
-    Mongoid::IdentityMap.clear
-  end
-  config.after(:all) do
-    Mongoid.default_session.drop
-  end
-end