promiscuous 0.53.1 → 0.90.0

data/lib/promiscuous/publisher/model/active_record.rb

@@ -1,25 +1,18 @@
 module Promiscuous::Publisher::Model::ActiveRecord
   extend ActiveSupport::Concern
+  include Promiscuous::Publisher::Model::Base
 
-  module ModelInstanceMethods
-    extend ActiveSupport::Concern
+  # TODO FIXME This needs some serious work. We need to hook deeper.
 
-    def with_promiscuous(options={}, &block)
-      fetch_proc = proc { self.class.find(self.id) }
-      self.class.promiscuous_publisher.new(options.merge(:instance => self, :fetch_proc => fetch_proc)).commit(&block)
-    end
-
-    included do
-      around_create  { |&block| with_promiscuous(:operation => :create,  &block) }
-      around_update  { |&block| with_promiscuous(:operation => :update,  &block) }
-      around_destroy { |&block| with_promiscuous(:operation => :destroy, &block) }
-    end
+  included do
+    around_create  { |&block| promiscuous.sync(:operation => :create,  &block) }
+    around_update  { |&block| promiscuous.sync(:operation => :update,  &block) }
+    around_destroy { |&block| promiscuous.sync(:operation => :destroy, &block) }
   end
 
   module ClassMethods
-    def setup_class_binding
-      super
-      klass.__send__(:include, ModelInstanceMethods) if klass
+    def __promiscuous_missing_record_exception
+      ActiveRecord::RecordNotFound
     end
   end
 end

data/lib/promiscuous/publisher/model/base.rb

@@ -0,0 +1,136 @@
+module Promiscuous::Publisher::Model::Base
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :publish_to, :published_attrs, :tracked_attrs
+    cattr_accessor  :published_db_fields # There is one on each root class, none on the subclasses
+    self.published_attrs = []
+    self.tracked_attrs = []
+    self.published_db_fields = []
+    track_dependencies_of :id
+    Promiscuous::Publisher::Model.publishers[self.promiscuous_collection_name] = self
+  end
+
+  module PromiscuousMethodsBase
+    def initialize(instance)
+      @instance = instance
+    end
+
+    def sync(options={}, &block)
+      options = {:instance => @instance, :operation => :update}.merge(options)
+      Promiscuous::Publisher::Operation::Base.new(options).execute(&block)
+    end
+
+    def payload(options={})
+      # It's nice to see the entire payload in one piece, not merged 36 times
+      # TODO migrate this format to something that makes more sense once the store is out
+      msg = {}
+      msg[:__amqp__]  = @instance.class.publish_to
+      msg[:type]      = @instance.class.publish_as # for backward compatibility
+      msg[:ancestors] = @instance.class.ancestors.select { |a| a < Promiscuous::Publisher::Model::Base }.map(&:publish_as)
+      msg[:id]        = @instance.id.to_s
+      if @instance.respond_to?(:promiscuous_payload)
+        msg[:payload] = @instance.promiscuous_payload
+      else
+        msg[:payload] = self.attributes unless options[:with_attributes] == false
+      end
+      msg
+    end
+
+    def attributes
+      Hash[@instance.class.published_attrs.map { |attr| [attr, self.attribute(attr)] }]
+    end
+
+    def attribute(attr)
+      value = @instance.__send__(attr)
+      value = value.promiscuous.payload if value.respond_to?(:promiscuous)
+      value
+    end
+
+    def get_dependency(attr, value)
+      return nil unless value
+      @collection ||= @instance.class.promiscuous_collection_name
+      Promiscuous::Dependency.new(@collection, attr, value)
+    end
+
+    def tracked_dependencies(options={})
+      # FIXME This is not sufficient, we need to consider the previous and next
+      # values in case of an update.
+      # Note that the caller expect the id dependency to come first
+      @instance.class.tracked_attrs
+        .map { |attr| [attr, @instance.__send__(attr)] }
+        .map { |attr, value| get_dependency(attr, value) }
+        .compact
+    end
+  end
+
+  class PromiscuousMethods
+    include Promiscuous::Publisher::Model::Base::PromiscuousMethodsBase
+  end
+
+  def promiscuous
+    # XXX Not thread safe
+    @promiscuous ||= self.class.const_get(:PromiscuousMethods).new(self)
+  end
+
+  def valid?(*args)
+    # Validations are not dependencies
+    # TODO we should yell if the user is trying to write
+    without_promiscuous { super }
+  end
+
+  module ClassMethods
+    # all methods are virtual
+
+    def publish(*args, &block)
+      options    = args.extract_options!
+      attributes = args.map(&:to_sym)
+
+      # TODO reject invalid options
+
+      if attributes.present? && self.publish_to && options[:to] && self.publish_to != options[:to]
+        raise 'versionned publishing is not supported yet'
+      end
+      self.publish_to ||= options[:to] || "#{Promiscuous::Config.app}/#{self.name.underscore}"
+      @publish_as = options[:as].to_s if options[:as]
+
+      ([self] + descendants).each do |klass|
+        # When the user passes :use => [:f1, :f2] for example, operation/mongoid.rb
+        # can track f1 and f2 as fields important for the publishing.
+        # It's important for virtual attributes. The published_db_fields is global
+        # for the entire subclass tree.
+        klass.published_db_fields |= [options[:use]].flatten.map(&:to_sym) if options[:use]
+        klass.published_db_fields |= attributes # aliased fields are resolved later
+        klass.published_attrs     |= attributes
+      end
+    end
+
+    def track_dependencies_of(*attributes)
+      ([self] + descendants).each { |klass| klass.tracked_attrs |= attributes.map(&:to_sym) }
+    end
+
+    def promiscuous_collection_name
+      self.name.pluralize.underscore
+    end
+
+    def get_operation_class_for(operation)
+      Promiscuous::Publisher::Operation::Base
+    end
+
+    def publish_as
+      @publish_as || name
+    end
+
+    def inherited(subclass)
+      super
+      subclass.published_attrs = self.published_attrs.dup
+      subclass.tracked_attrs   = self.tracked_attrs.dup
+      # no copy for published_db_fields
+    end
+
+    class None; end
+    def promiscuous_missing_record_exception
+      None
+    end
+  end
+end

data/lib/promiscuous/publisher/model/ephemeral.rb

@@ -0,0 +1,69 @@
+module Promiscuous::Publisher::Model::Ephemeral
+  extend ActiveSupport::Concern
+  include Promiscuous::Publisher::Model::Base
+
+  attr_accessor :id, :new_record, :destroyed
+
+  module PromiscuousMethodsEphemeral
+    def attribute(attr)
+      value = super
+      if value.is_a?(Array) &&
+         value.first.is_a?(Promiscuous::Publisher::Model::Ephemeral)
+         value = {:__amqp__ => '__promiscuous__/embedded_many',
+                  :payload  => value.map(&:promiscuous).map(&:payload)}
+      end
+      value
+    end
+  end
+
+  class PromiscuousMethods
+    include Promiscuous::Publisher::Model::Base::PromiscuousMethodsBase
+    include Promiscuous::Publisher::Model::Ephemeral::PromiscuousMethodsEphemeral
+  end
+
+  def initialize(attrs={})
+    self.id ||= 'none'
+    self.new_record = true
+    self.destroyed = false
+    attrs.each { |attr, value| __send__("#{attr}=", value) }
+  end
+
+  def save
+    operation = :create
+    operation = :update  unless self.new_record
+    operation = :destroy if     self.destroyed
+    promiscuous.sync(:operation => operation)
+    self.new_record = false
+    true
+  end
+  alias :save! :save
+
+  def update_attributes(attrs)
+    attrs.each { |attr, value| __send__("#{attr}=", value) }
+    save
+  end
+  alias :update_attributes! :update_attributes
+
+  def destroy
+    self.destroyed = true
+    save
+  end
+
+  def attributes
+    Hash[self.class.published_attrs.map { |attr| [attr, __send__(attr)] }]
+  end
+
+  module ClassMethods
+    def publish(*args)
+      super
+      published_attrs.each do |attr|
+        # TODO do not overwrite existing methods
+        attr_accessor attr
+      end
+    end
+
+    def create(attributes)
+      new(attributes).tap { |m| m.save }
+    end
+  end
+end

data/lib/promiscuous/publisher/model/mock.rb

@@ -0,0 +1,61 @@
+module Promiscuous::Publisher::Model::Mock
+  extend ActiveSupport::Concern
+  include Promiscuous::Publisher::Model::Ephemeral
+
+  included { class_attribute :mock_options }
+
+  def initialize(attrs={})
+    self.id = __get_new_id
+    super
+  end
+
+  def __get_new_id
+    if self.class.mock_options.try(:[], :id) == :bson
+      BSON::ObjectId.new
+    else
+      # XXX Not thread safe
+      @@next_id ||= 1
+      @@next_id += 1
+    end
+  end
+
+  class PromiscuousMethods
+    include Promiscuous::Publisher::Model::Base::PromiscuousMethodsBase
+    include Promiscuous::Publisher::Model::Ephemeral::PromiscuousMethodsEphemeral
+
+    def sync(options={}, &block)
+      payload = self.payload
+      payload[:operation] = options[:operation] || :update
+      Promiscuous::Subscriber::Worker::Message.new(MultiJson.dump(payload)).process
+    end
+  end
+
+  module ClassMethods
+    def publish_as
+      # The mocks are in the publisher's namespace, so we need to remove that.
+      @publish_as ||= ($2 if self.name =~ /^(.+)::Publishers::(.+)$/)
+    end
+
+    def mock(options={})
+      self.mock_options = options
+    end
+
+    def publish(*args, &block)
+      super
+
+      args.extract_options!
+      attributes = args
+      attr_accessor(*attributes)
+
+      # Hacks for associations on the factory
+      associations = attributes.map { |attr| $1 if attr =~ /^(.*)_id$/ }.compact
+      associations.each do |attr|
+        attr_accessor(attr)
+        define_method("#{attr}=") do |value|
+          instance_variable_set("@#{attr}", value)
+          instance_variable_set("@#{attr}_id", value.nil? ? value : value.id)
+        end
+      end
+    end
+  end
+end

data/lib/promiscuous/publisher/model/mongoid.rb

@@ -1,129 +1,86 @@
 module Promiscuous::Publisher::Model::Mongoid
   extend ActiveSupport::Concern
+  include Promiscuous::Publisher::Model::Base
 
-  class Commit
-    attr_accessor :collection, :selector, :document, :operation
-    def initialize(options={})
-      self.collection = options[:collection]
-      self.selector   = options[:selector]
-      self.document   = options[:document]
-      self.operation  = options[:operation]
-    end
+  mattr_accessor :collection_mapping
+  self.collection_mapping = {}
 
-    def klass
-      @klass ||= document.try(:[], '_type').try(:constantize) ||
-                 collection.singularize.camelize.constantize
-    rescue NameError
-    end
+  # We hook at the database driver level
+  require 'promiscuous/publisher/operation/mongoid'
+  included do
+    # Important for the query hooks (see ../operation/mongoid.rb)
+    # We want the root class when we do a collection name lookup
 
-    def fetch
-      case operation
-      when :create  then klass.new(document, :without_protection => true)
-      when :update  then klass.with(:consistency => :strong).where(selector).first
-      when :destroy then klass.with(:consistency => :strong).where(selector).first
-      end
+    root_class = self.collection.name.singularize.camelize.constantize
+    unless self == root_class
+      raise "Please include Promiscuous::Publisher in #{root_class} first (the root class)"
     end
 
-    def commit(&block)
-      return block.call unless klass
-
-      # We bypass the call if instance == nil, the destroy or the update would
-      # have had no effect
-      instance = fetch
-      return if instance.nil?
-
-      return block.call unless instance.class.respond_to?(:promiscuous_publisher)
-
-      self.selector = {:id => instance.id}
-
-      publisher = instance.class.promiscuous_publisher
-      publisher.new(:operation  => operation,
-                    :instance   => instance,
-                    :fetch_proc => method(:fetch)).commit(&block)
-    end
+    Promiscuous::Publisher::Model::Mongoid.collection_mapping[self.collection.name] = self
   end
 
-  module ModelInstanceMethods
-    extend ActiveSupport::Concern
-
-    def promiscuous_sync
-      publisher = self.class.promiscuous_publisher
+  class PromiscuousMethods
+    include Promiscuous::Publisher::Model::Base::PromiscuousMethodsBase
 
-      fetch_proc = proc { self.class.with(:consistency => :strong).where(atomic_selector).first }
+    def sync(options={}, &block)
+      raise "Use promiscuous.sync on the parent instance" if @instance.embedded?
+      super
+    end
 
-      publisher.new(:operation  => :update,
-                    :instance   => self,
-                    :fetch_proc => fetch_proc).commit
+    def attribute(attr)
+      value = super
+      if value.is_a?(Array) &&
+         value.respond_to?(:ancestors) &&
+         value.ancestors.any? { |a| a == Promiscuous::Publisher::Model::Mongoid }
+         value = {:__amqp__ => '__promiscuous__/embedded_many',
+                  :payload  => value.map(&:promiscuous).map(&:payload)}
+      end
+      value
     end
   end
 
   module ClassMethods
-    def setup_class_binding
+    # TODO DRY this up with the publisher side
+    def publish(*args, &block)
       super
-      klass.__send__(:include, ModelInstanceMethods) if klass
-    end
-  end
+      return unless block
 
-  def self.hook_mongoid
-    Moped::Collection.class_eval do
-      alias_method :insert_orig, :insert
-      def insert(documents, flags=nil)
-        documents = [documents] unless documents.is_a?(Array)
-        documents.each do |doc|
-          Promiscuous::Publisher::Model::Mongoid::Commit.new(
-            :collection => self.name,
-            :document   => doc,
-            :operation  => :create
-          ).commit do
-            insert_orig(doc, flags)
-          end
-        end
+      begin
+        @in_publish_block = true
+        block.call
+      ensure
+        @in_publish_block = false
       end
     end
 
-    Moped::Query.class_eval do
-      alias_method :update_orig, :update
-      def update(change, flags=nil)
-        if flags && flags.include?(:multi)
-          raise "Promiscuous: Do not use multi updates, update each instance separately"
-        end
-
-        Promiscuous::Publisher::Model::Mongoid::Commit.new(
-          :collection => collection.name,
-          :selector   => selector,
-          :operation  => :update
-        ).commit do
-          update_orig(change, flags)
+    def self.publish_on(method, options={})
+      define_method(method) do |name, *args, &block|
+        super(name, *args, &block)
+        if @in_publish_block
+          name = args.last[:as] if args.last.is_a?(Hash) && args.last[:as]
+          publish(name)
         end
       end
+    end
 
-      alias_method :modify_orig, :modify
-      def modify(change, options={})
-        Promiscuous::Publisher::Model::Mongoid::Commit.new(
-          :collection => collection.name,
-          :selector   => selector,
-          :operation  => :update
-        ).commit do
-          modify_orig(change, options)
-        end
-      end
+    publish_on :field
+    publish_on :embeds_one
+    publish_on :embeds_many
 
-      alias_method :remove_orig, :remove
-      def remove
-        Promiscuous::Publisher::Model::Mongoid::Commit.new(
-          :collection => collection.name,
-          :selector   => selector,
-          :operation  => :destroy
-        ).commit do
-          remove_orig
-        end
-      end
+    def promiscuous_collection_name
+      self.collection.name
+    end
 
-      alias_method :remove_all_orig, :remove_all
-      def remove_all
-        raise "Promiscuous: Do not use delete_all, use destroy_all"
+    def get_operation_class_for(operation)
+      if operation == :create
+        Moped::PromiscuousCollectionWrapper::PromiscuousCollectionOperation
+      else
+        Moped::PromiscuousQueryWrapper::PromiscuousQueryOperation
       end
     end
+
+    def promiscuous_missing_record_exception
+      Mongoid::Errors::DocumentNotFound
+    end
   end
-  hook_mongoid
 end