promiscuous 0.100.5 → 1.0.0.beta1

data/lib/promiscuous/dependency.rb

@@ -1,78 +0,0 @@
-require 'fnv'
-
-class Promiscuous::Dependency
-  attr_accessor :internal_key, :version, :type
-
-  def initialize(*args)
-    options = args.extract_options!
-    @type = options[:type]
-    @owner = options[:owner]
-    @dont_hash = options[:dont_hash]
-
-    @internal_key = args.join('/')
-
-    if @internal_key =~ /^[0-9]+$/
-      @internal_key = @internal_key.to_i
-      @hash = @internal_key
-    else
-      @hash = FNV.new.fnv1a_32(@internal_key)
-
-      if Promiscuous::Config.hash_size.to_i > 0
-        # We hash dependencies to have a O(1) memory footprint in Redis.
-        # The hashing needs to be deterministic across instances in order to
-        # function properly.
-        @hash = @hash % Promiscuous::Config.hash_size.to_i
-        @internal_key = @hash unless @dont_hash
-      end
-    end
-
-    if @owner
-      @internal_key = "#{@owner}:#{@internal_key}"
-    end
-  end
-
-  def read?
-    raise "Type not set" unless @type
-    @type == :read
-  end
-
-  def write?
-    raise "Type not set" unless @type
-    @type == :write
-  end
-
-  def key(role)
-    Promiscuous::Key.new(role).join(@internal_key)
-  end
-
-  def redis_node(distributed_redis=nil)
-    distributed_redis ||= Promiscuous::Redis.master
-    distributed_redis.nodes[@hash % distributed_redis.nodes.size]
-  end
-
-  def as_json(options={})
-    @version ? [@internal_key, @version].join(':') : @internal_key
-  end
-
-  def self.parse(payload, options={})
-    case payload
-    when /^(.+):([0-9]+)$/ then new($1, options).tap { |d| d.version = $2.to_i }
-    when /^(.+)$/          then new($1, options)
-    end
-  end
-
-  def to_s
-    as_json.to_s
-  end
-
-  # We need the eql? method to function properly (we use ==, uniq, ...) in operation
-  # XXX The version is not taken in account.
-  def eql?(other)
-    self.internal_key == other.internal_key
-  end
-  alias == eql?
-
-  def hash
-    self.internal_key.hash
-  end
-end

data/lib/promiscuous/error/dependency.rb

@@ -1,116 +0,0 @@
-class Promiscuous::Error::Dependency < Promiscuous::Error::Base
-  attr_accessor :dependency_solutions, :operation
-
-  def initialize(options={})
-    self.operation = options[:operation]
-  end
-
-  # TODO Convert all that with Erb
-
-  def message
-    msg = nil
-    case operation.operation
-    when :read
-      msg =  "Promiscuous doesn't have any tracked dependencies to perform this multi read operation.\n" +
-             "This is what you can do:\n\n" +
-             "  1. Bypass Promiscuous\n\n" +
-             "     If you don't use the result of this operation in your following writes,\n" +
-             "     you can wrap your read query in a 'without_promiscuous { }' block.\n" +
-             "     This is the preferred solution when you are sure that the read doesn't\n" +
-             "     influence the value of a published attribute.\n\n" +
-             "     Rule of thumb: Predicates (methods ending with ?) are often suitable for this use case.\n\n"
-      cnt = 2
-      if operation.operation_ext != :count
-        msg += "  #{cnt}. Synchronize on individual instances\n\n" +
-               "     If the collection you are iterating through is small (<10), it becomes intersting\n" +
-               "     to track instances through their ids instead of the query selector. Example:\n\n" +
-               "          criteria.without_promiscuous.each do |doc|\n" +
-               "            next if doc.should_do_something?\n" +
-               "            doc.reload # tell promiscuous to track the instance\n" +
-               "            doc.do_something!\n" +
-               "          end\n\n"
-        cnt += 1
-      end
-      if operation.selector_keys.present?
-        msg += "  #{cnt}. Track New Dependencies\n\n" +
-               "     Add #{operation.selector_keys.count == 1 ? "the following line" : "one of the following lines"} " +
-                    "in the #{operation.instance.class} model:\n\n" +
-               "       class #{operation.instance.class}\n" +
-                    operation.selector_keys.map { |field| "         track_dependencies_of :#{field}" }.join("\n") + "\n" +
-               "       end\n\n" +
-               (operation.selector_keys.count > 1 ?
-               "     The more specific field, the better. Promiscuous works better when working with small subsets\n" +
-               "     For example, tracking something like 'member_id' is a fairly safe choice.\n\n" : "") +
-               "     Note that dependency tracking slows down your writes. It can be seen as the analogous\n" +
-               "     of an index on a regular database.\n" +
-               "     You may find more information about the implications in the Promiscuous wiki (TODO:link).\n\n"
-      end
-    when :update
-      msg = "Promiscuous cannot track dependencies of a multi update operation.\n" +
-             "This is what you can do:\n\n" +
-             "  1. Instead of doing a multi updates, update each instance separately\n\n" +
-             "  2. Do not assign has_many associations directly, but use the << operator instead.\n\n"
-    when :destroy
-      msg = "Promiscuous cannot track dependencies of a multi delete operation.\n" +
-             "This is what you can do:\n\n" +
-            "   1. Instead of doing a multi delete, delete each instance separatly.\n\n" +
-            "   2. Use destroy_all instead of destroy_all.\n\n" +
-            "   3. Declare your has_many relationships with :dependent => :destroy instead of :delete.\n\n"
-    end
-
-    msg += "#{"-" * 100}\n\n"
-
-    msg += "Promiscuous cannot allow the following "
-    case operation.operation_ext || operation.operation
-    when :count     then msg += 'count'
-    when :mapreduce then msg += 'mapreduce'
-    when :read      then msg += 'each loop'
-    when :update    then msg += 'multi update'
-    when :destroy   then msg += 'multi destroy'
-    end
-    msg += "  #{self.class.explain_operation(self.operation)}"
-    msg += "\n\nProTip: Try again with TRACE=2 in the shell or ENV['TRACE']='2' in the console.\n" unless ENV['TRACE']
-    msg
-  rescue Exception => e
-    "#{e}\n#{e.backtrace.join("\n")}"
-  end
-
-  def self.explain_operation(operation, limit=100)
-    instance = operation.instance
-    selector   = instance ? get_selector(instance.attributes, limit) : ""
-    class_name = instance ? instance.class : "Unknown"
-
-    if operation.operation == :create
-      "#{instance.class}.create(#{selector})"
-    else
-      case operation.operation_ext || operation.operation
-      when :count     then verb = 'count'
-      when :mapreduce then verb = 'mapreduce(...)'
-      when :read      then verb = operation.multi? ? 'each { ... }' : 'first'
-      when :update    then verb = operation.multi? ? 'update_all'   : 'update'
-      when :destroy   then verb = operation.multi? ? 'delete_all'   : 'delete'
-      end
-      msg = "#{class_name}#{selector.present? ? ".where(#{selector})" : ""}.#{verb}"
-      if operation.operation == :update && operation.respond_to?(:change) && operation.change
-        msg += "(#{get_selector(operation.change, limit)})"
-      end
-
-      if operation.operation == :commit
-        msg = "Transaction commit"
-      end
-
-      msg
-    end
-  end
-
-  def self.get_selector(attributes, limit=100)
-    # TODO ActiveRecord?
-    attributes = attributes['$set'] if attributes.count == 1 && attributes['$set']
-    attributes.reject! { |k,v| v.nil? }
-    selector = attributes.map { |k,v| ":#{k} => #{v}" }.join(", ")
-    selector = "#{selector[0...(limit-3)]}..." if selector.size > limit
-    selector
-  end
-
-  alias to_s message
-end