apartment 0.22.1 → 0.23.0

data/lib/apartment/delayed_job/psych_ext.rb

@@ -1,61 +0,0 @@
-if defined?(ActiveRecord)
-  class ActiveRecord::Base
-    # @override
-    # serialize to YAML
-    def encode_with(coder)
-      coder["attributes"] = @attributes
-      coder["database"] =   @database unless @database.nil?
-      coder.tag = ['!ruby/ActiveRecord', self.class.name].join(':')
-    end
-  end
-end
-
-module Psych
-  module Visitors
-    class ToRuby
-      #   @override
-      #
-      #   NOTE I don't have a great idea what's going on here...
-      #   The only change is the `Apartment::Database.process`
-      #
-      def visit_Psych_Nodes_Mapping_with_class_and_db(object)
-        return revive(Psych.load_tags[object.tag], object) if Psych.load_tags[object.tag]
-
-        case object.tag
-        when /^!ruby\/ActiveRecord:(.+)$/
-          klass = resolve_class($1)
-          payload = Hash[*object.children.map { |c| accept c }]
-          id = payload["attributes"][klass.primary_key]
-          begin
-            Apartment::Database.process(payload['database']) do
-              klass.unscoped.find(id)
-            end
-          rescue ActiveRecord::RecordNotFound
-            raise Delayed::DeserializationError
-          end
-        when /^!ruby\/Mongoid:(.+)$/
-          klass = resolve_class($1)
-          payload = Hash[*object.children.map { |c| accept c }]
-          begin
-            klass.find(payload["attributes"]["_id"])
-          rescue Mongoid::Errors::DocumentNotFound
-            raise Delayed::DeserializationError
-          end
-        when /^!ruby\/DataMapper:(.+)$/
-          klass = resolve_class($1)
-          payload = Hash[*object.children.map { |c| accept c }]
-          begin
-            primary_keys = klass.properties.select { |p| p.key? }
-            key_names = primary_keys.map { |p| p.name.to_s }
-            klass.get!(*key_names.map { |k| payload["attributes"][k] })
-          rescue DataMapper::ObjectNotFoundError
-            raise Delayed::DeserializationError
-          end
-        else
-          visit_Psych_Nodes_Mapping_without_class_and_db(object)
-        end
-      end
-      alias_method_chain :visit_Psych_Nodes_Mapping, :class_and_db
-    end
-  end
-end

data/lib/apartment/delayed_job/requirements.rb

@@ -1,23 +0,0 @@
-require 'apartment/delayed_job/enqueue'
-
-module Apartment
-  module Delayed
-
-    # Mix this module into any ActiveRecord model that gets serialized by DJ
-    module Requirements
-      attr_accessor :database
-
-      def self.included(klass)
-        klass.after_find :set_database      # set db when records are pulled so they deserialize properly
-        klass.before_save :set_database     # set db before records are saved so that they also get deserialized properly
-      end
-
-    private
-
-      def set_database
-        @database = Apartment::Database.current_database
-      end
-
-    end
-  end
-end

data/lib/apartment/delayed_job/syck_ext.rb

@@ -1,29 +0,0 @@
-module ActiveRecord
-  class Base
-
-    # Overriding Delayed Job's monkey_patch of ActiveRecord so that it works with Apartment
-    yaml_as "tag:ruby.yaml.org,2002:ActiveRecord"
-
-    def self.yaml_new(klass, tag, val)
-      Apartment::Database.process(val['database']) do
-        klass.find(val['attributes']['id'])
-      end
-    rescue ActiveRecord::RecordNotFound => e
-      raise Delayed::DeserializationError,  e.message
-    end
-
-    # Rails > 3.0 now uses encode_with to determine what to encode with yaml
-    # @override to include database attribute
-    def encode_with_with_database(coder)
-      coder['database'] = @database if @database.present?
-      encode_with_without_database(coder)
-    end
-    alias_method_chain :encode_with, :database
-
-    # Remain backwards compatible with old yaml serialization
-    def to_yaml_properties
-      ['@attributes', '@database']    # add in database attribute for serialization
-    end
-
-  end
-end

data/spec/dummy/lib/fake_dj_class.rb

@@ -1,6 +0,0 @@
-class FakeDjClass
-  
-  def perform
-  end
-  
-end

data/spec/integration/delayed_job_integration_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-require 'delayed_job'
-require 'delayed_job_active_record'
-
-describe Apartment::Delayed do
-  unless defined?(JRUBY_VERSION)
-
-    # See apartment.yml file in dummy app config
-
-    let(:config) { Apartment::Test.config['connections']['postgresql'].symbolize_keys }
-    let(:database) { Apartment::Test.next_db }
-    let(:database2) { Apartment::Test.next_db }
-
-    before do
-      ActiveRecord::Base.establish_connection config
-      Apartment::Test.load_schema   # load the Rails schema in the public db schema
-      Apartment::Database.stub(:config).and_return config   # Use postgresql database config for this test
-
-      Apartment.configure do |config|
-        config.use_schemas = true
-      end
-
-      Apartment::Database.create database
-      Apartment::Database.create database2
-    end
-
-    after do
-      Apartment::Test.drop_schema database
-      Apartment::Test.drop_schema database2
-      Apartment.reset
-    end
-
-    describe Apartment::Delayed::Requirements do
-
-      before do
-        Apartment::Database.switch database
-        User.send(:include, Apartment::Delayed::Requirements)
-        User.create
-      end
-
-      it "should initialize a database attribute on a class" do
-        user = User.first
-        user.database.should == database
-      end
-
-      context 'when there are defined callbacks' do
-        before do
-          User.class_eval do
-            after_find :set_name
-
-            def set_name
-              self.name = "Some Name"
-            end
-          end
-        end
-
-        after do
-          User.class_eval do
-            reset_callbacks :find
-          end
-        end
-
-        it "should not overwrite any previous after_initialize declarations" do
-          user = User.first
-          user.database.should == database
-          user.name.should == "Some Name"
-        end
-      end
-
-      it "should set the db on a new record before it saves" do
-        user = User.create
-        user.database.should == database
-      end
-
-      context "serialization" do
-        it "should serialize the proper database attribute" do
-          user_yaml = User.first.to_yaml
-          Apartment::Database.switch database2
-          user = YAML.load user_yaml
-          user.database.should == database
-        end
-      end
-    end
-
-    describe Apartment::Delayed::Job::Hooks do
-
-      let(:worker) { Delayed::Worker.new }
-      let(:job) { Delayed::Job.enqueue User.new }
-
-      it "should switch to previous db" do
-        Apartment::Database.switch database
-        worker.run(job)
-
-        Apartment::Database.current_database.should == database
-      end
-    end
-
-  end
-end