mongoid-publishable 0.0.1

data/lib/mongoid/publishable/queue.rb

@@ -0,0 +1,51 @@
+require "mongoid/publishable/unpublished_object"
+
+module Mongoid
+  module Publishable
+    class Queue < Array
+
+      # loads the queue from the session
+      def self.load(session = nil)
+        # create a new queue
+        queue = new
+        # if there was no existing queue, return new
+        return queue unless session
+        # create our contents
+        contents = session.split("\n").map do |data|
+          UnpublishedObject.deserialize_from_session(data)
+        end
+        # add into the queue
+        queue.replace(contents)
+      end
+      
+      # publishes all the objects on the queue to this user
+      def publish_via(publisher)
+        remaining = delete_if do |model|
+          model.publish_via!(publisher)
+          model.published?
+        end
+        # replaces the contents with the remaining models
+        replace(remaining)
+      end
+      
+      # creates a string containing the data of the queue
+      def dump
+        map do |model|
+          model.serialize_for_session
+        end.join("\n")
+      end
+      
+      # adds a new object to the queue
+      def push(*models)
+        # map each item to an unpublished object
+        models = Array(models).map do |model|
+          UnpublishedObject.new(model: model)
+        end
+        # add them to the array
+        super(*models)
+      end
+      alias_method :<<, :push
+
+    end
+  end
+end

data/lib/mongoid/publishable/queuing.rb

@@ -0,0 +1,27 @@
+require "mongoid/publishable/queue"
+
+module Mongoid
+  module Publishable
+    module Queuing
+      def self.included(base)
+        base.class_eval do
+          before_filter :deserialize_publishing_queue
+          after_filter  :serialize_publishing_queue
+          attr_reader   :publishing_queue
+        end
+        base.send(:include, InstanceMethods)
+      end
+      
+      module InstanceMethods
+        protected
+        def deserialize_publishing_queue
+          @publishing_queue = Queue.load(session[:publishing_queue])
+        end
+        
+        def serialize_publishing_queue
+          session[:publishing_queue] = @publishing_queue.dump
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/publishable/unpublished_error.rb

@@ -0,0 +1,7 @@
+module Mongoid
+  module Publishable
+    class UnpublishedError < StandardError
+      attr_accessor :model
+    end
+  end
+end

data/lib/mongoid/publishable/unpublished_object.rb

@@ -0,0 +1,88 @@
+require "multi_json"
+
+module Mongoid
+  module Publishable
+    class UnpublishedObject
+      def self.deserialize_from_session(data)
+        new(data: data)
+      end
+      
+      def initialize(options = {})
+        if options[:model]
+          @source_object = options[:model]
+        elsif options[:data]
+          @serialized_data = options[:data]
+        else
+          raise ArgumentError, "No :model or :data provided"
+        end
+      end
+      
+      def serialize_for_session
+        @serialized_data ||= serialize_object_for_session
+      end
+      
+      def params
+        MultiJson.load(@serialized_data)
+      end
+      
+      def respond_to_missing?(method)
+        source_object.respond_to?(method)
+      end
+      
+      def method_missing(method, *args, &block)
+        if respond_to_missing?(method)
+          source_object.send(method, *args, &block)
+        else
+          super
+        end
+      end
+      
+      def source_object
+        @source_object ||= load_source_object_from_params
+      end
+      
+      private
+      def load_source_object_from_params
+        data = params
+        # load the top level object
+        object = data["class_name"].constantize.find(data["id"])
+        # if we have embedded stuff
+        while data["embedded"]
+          # work on the next level down
+          data = data["embedded"]
+          # find the nested object
+          object = object.send(data["association"]).find(data["id"])
+        end
+        # once at the bottom, return the object
+        object
+      end
+      
+      def serialize_object_for_session
+        # start at the bottom
+        object = source_object
+        result = nil
+        # work the way up the embeds
+        while object.embedded?
+          # select the relation for the parent object
+          parent_relation = relations.select do |k,v|
+            v.macro == :embedded_in && v.class_name == object._parent.class.name
+          end.values.first
+          # wrap the the result
+          result = {
+            embedded: {
+              association: parent_relation.inverse_of,
+              embedded: result,
+              id: object.id
+            }
+          }
+          # now act on the parent
+          object = object._parent
+        end
+        # when at the top level, store the class/id/result
+        result = { class_name: object.class.name, id: object.id, embedded: result }
+        # convert the result to JSON
+        MultiJson.dump(result)
+      end
+    end
+  end
+end

data/lib/mongoid/publishable/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module Publishable
+    VERSION = "0.0.1"
+  end
+end

data/lib/mongoid_publishable.rb

@@ -0,0 +1,2 @@
+require "mongoid/publishable"
+require "mongoid/publishable/version"

data/mongoid_publishable.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "mongoid/publishable/version"
+
+Gem::Specification.new do |s|
+  s.name          = "mongoid-publishable"
+  s.version       = Mongoid::Publishable::VERSION
+  s.authors       = ["Ryan Townsend"]
+  s.email         = ["ryan@ryantownsend.co.uk"]
+  s.description   = %q{A mixin for Mongoid document models allowing for publishing them after authentication}
+  s.summary       = s.description
+  s.homepage      = "https://github.com/ryantownsend/mongoid-publishable"
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+  
+  s.add_dependency "mongoid"
+  s.add_dependency "multi_json"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "simplecov"
+end

data/spec/mongoid/publishable/callback_collection_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+require "mongoid/publishable/callback_collection"
+
+describe Mongoid::Publishable::CallbackCollection do
+  let(:callback) { mock("callback") }
+  let(:contents) { [callback] }
+  subject { Mongoid::Publishable::CallbackCollection.new(contents) }
+
+  describe "#process" do
+    it "should call #process on each of it's items" do
+      object = mock("instance")
+      callback.should_receive(:process).with(object).and_return(true)
+      subject.process(object)
+    end
+  end
+
+end

data/spec/mongoid/publishable/callback_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+require "mongoid/publishable/callback"
+
+describe Mongoid::Publishable::Callback do
+  subject { Mongoid::Publishable::Callback }
+
+  describe "#initialize" do
+    it "should accept a block" do
+      callback = subject.new do |object|
+        puts "Done something"
+      end
+      expect(callback).to respond_to :process
+    end
+    
+    it "should accept a symbol" do
+      callback = subject.new(:method_name)
+      expect(callback).to respond_to :process
+    end
+    
+    it "should not accept two arguments" do
+      expect {
+        subject.new(:one, :two)
+      }.to raise_error(ArgumentError)
+    end
+  end
+  
+  describe "#process" do
+    let(:object) { mock("instance", test: "123") }
+    
+    context "when given a method name" do
+      it "should call the method on the given object" do
+        callback = subject.new(:test)
+        expect(callback.process(object)).to eq "123"
+      end
+    end
+    
+    context "when given a block" do
+      it "should yield the block with the given object" do
+        callback = subject.new do |object|
+          object.test
+        end
+        expect(callback.process(object)).to eq "123"
+      end
+    end
+  end
+end

data/spec/mongoid/publishable/callbacks_spec.rb

@@ -0,0 +1,72 @@
+require "spec_helper"
+require "mongoid/publishable/callbacks"
+
+describe Mongoid::Publishable::Callbacks do
+
+  context "a class that's included Mongoid::Publishable::Callbacks" do
+
+    subject do
+      CallbackableObject
+    end
+    
+    describe "::after_publish_callbacks" do
+      it "should return an object that responds to #process" do
+        expect(subject.after_publish_callbacks).to respond_to :process
+      end
+    end
+  
+    describe "::after_publish" do
+      it "should increment the callbacks by 1" do
+        subject.after_publish_callbacks.replace []
+        expect(subject.after_publish_callbacks.size).to eq 0
+        subject.after_publish(:method_name)
+        expect(subject.after_publish_callbacks.size).to eq 1
+      end
+  
+      it "should accept a block" do
+        callback = subject.after_publish do |object|
+          puts "Done something"
+        end
+        expect(callback).to respond_to :process
+      end
+    
+      it "should accept a symbol" do
+        callback = subject.after_publish(:method_name)
+        expect(callback).to respond_to :process
+      end
+    end
+
+  end # class
+  
+  context "an instance class that's included Mongoid::Publishable::Callbacks" do
+
+    subject do
+      CallbackableObject.new
+    end
+
+    describe "#process_after_publish_callbacks" do
+      it "should process the callbacks" do
+        collection = subject.class.after_publish_callbacks
+        collection.should_receive(:process).with(subject).and_return(true)
+        expect(subject.process_after_publish_callbacks).to be_true
+      end
+    end
+    
+    describe "#run_after_publish_callbacks?" do
+      context "by default" do
+        it "should return false" do
+          expect(subject.run_after_publish_callbacks?).to be_false
+        end
+      end
+      
+      context "after calling #run_after_publish_callbacks" do
+        it "should return true" do
+          subject.run_after_publish_callbacks
+          expect(subject.run_after_publish_callbacks?).to be_true
+        end
+      end
+    end
+
+  end # instance
+
+end

data/spec/mongoid/publishable/queue_spec.rb

@@ -0,0 +1,106 @@
+require "spec_helper"
+require "mongoid/publishable/queue"
+
+describe Mongoid::Publishable::Queue do
+
+  describe "the class" do
+    subject do
+      Mongoid::Publishable::Queue
+    end
+    
+    describe "::load" do
+      context "given session data" do
+        it "should create an unpublished object for each line" do
+          data = %Q({ class_name: "Item", id: 123 }\n{ class_name: "Item", id: 123 })
+          expect(subject.load(data).size).to eq 2
+        end
+      end
+      
+      context "given no session data" do
+        it "should return an empty queue" do
+          expect(subject.load.size).to eq 0
+        end
+      end
+    end
+  end
+  
+  describe "an instance of the queue" do
+    let(:items) { [] }
+    
+    subject do
+      Mongoid::Publishable::Queue.new(items)
+    end
+
+    describe "#publish_via" do
+      let(:item) do
+        mock("unpublished_item").tap do |item|
+          item.stub(:publish_via!).and_return(true)
+        end
+      end
+      let(:items) { [item] }
+
+      context "when all contents are published" do
+        before(:each) do
+          item.stub(:published?).and_return(true)
+        end
+        
+        it "should empty the queue" do
+          expect(subject.size).to eq 1
+          subject.publish_via(mock("user"))
+          expect(subject.size).to eq 0
+        end
+      end
+      
+      context "when one of the items cannot be published" do
+        before(:each) do
+          item.stub(:published?).and_return(false)
+        end
+        
+        it "should leave one item in the queue" do
+          expect(subject.size).to eq 1
+          subject.publish_via(mock("user"))
+          expect(subject.size).to eq 1
+        end
+      end
+    end
+    
+    describe "#dump" do
+      let(:item) do
+        mock("unpublished_item", serialize_for_session: "123")
+      end
+      let(:items) { [item, item] }
+
+      it "should serialize each object and join into a multi-line string" do
+        expect(subject.dump).to eq "123\n123"
+      end
+    end
+    
+    describe "#push" do
+      context "when given a single item" do
+        it "the number of objects should be incremented by 1" do
+          count = subject.size
+          subject.push(mock("model"))
+          expect(subject.size).to eq count + 1
+        end
+      end
+      
+      context "when given 2 items" do
+        it "the number of objects should be incremented by 2" do
+          count = subject.size
+          subject.push(mock("model"), mock("model"))
+          expect(subject.size).to eq count + 2
+        end
+      end
+      
+      context "when given no items" do
+        it "the number of objects should not change" do
+          count = subject.size
+          subject.push
+          expect(subject.size).to eq count
+        end
+      end
+    end
+
+  end # instance
+
+end