mr 0.35.2

data/lib/mr.rb

@@ -0,0 +1,11 @@
+require 'active_record'
+
+require 'mr/version'
+require 'mr/model'
+require 'mr/query'
+require 'mr/read_model'
+require 'mr/record'
+
+module MR
+
+end

data/lib/mr/after_commit.rb

@@ -0,0 +1,49 @@
+require 'much-plugin'
+
+require 'mr/after_commit/fake_record'
+require 'mr/after_commit/record'
+require 'mr/after_commit/record_procs_methods'
+require 'mr/model'
+
+module MR
+
+  module AfterCommit
+    include MuchPlugin
+
+    # demeter these constants so they are available from the `MR::AfterCommit`
+    # namespace
+    VALID_CALLBACK_TYPES  = RecordProcsMethods::VALID_CALLBACK_TYPES
+    DEFAULT_CALLBACK_TYPE = RecordProcsMethods::DEFAULT_CALLBACK_TYPE
+
+    plugin_included do
+      include MR::Model
+      include InstanceMethods
+    end
+
+    module InstanceMethods
+
+      def after_commit_procs(*args)
+        self.record.after_commit_procs(*args)
+      end
+
+      def after_commit(on = nil, &block)
+        self.record.add_after_commit_proc(on, &block)
+      end
+
+      def prepend_after_commit(on = nil, &block)
+        self.record.prepend_after_commit_proc(on, &block)
+      end
+
+      def clear_after_commit_procs(*args)
+        self.record.clear_after_commit_procs(*args)
+      end
+
+      def called_after_commit_procs(*args)
+        self.record.called_after_commit_procs(*args)
+      end
+
+    end
+
+  end
+
+end

data/lib/mr/after_commit/fake_record.rb

@@ -0,0 +1,39 @@
+require 'much-plugin'
+
+require 'mr/after_commit/record_procs_methods'
+require 'mr/fake_record'
+
+module MR; end
+module MR::AfterCommit
+
+  module FakeRecord
+    include MuchPlugin
+
+    plugin_included do
+      include MR::FakeRecord
+      include RecordProcsMethods
+      include InstanceMethods
+    end
+
+    module InstanceMethods
+
+      def save!
+        is_new = self.new_record?
+        super.tap do
+          callback_type = is_new ? :create : :update
+          mr_after_commit_call_procs(callback_type)
+          mr_after_commit_call_procs(:save)
+        end
+      end
+
+      def destroy
+        super.tap do
+          mr_after_commit_call_procs(:destroy)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/mr/after_commit/record.rb

@@ -0,0 +1,48 @@
+require 'much-plugin'
+
+require 'mr/after_commit/record_procs_methods'
+require 'mr/record'
+
+module MR; end
+module MR::AfterCommit
+
+  module Record
+    include MuchPlugin
+
+    plugin_included do
+      include MR::Record
+      include RecordProcsMethods
+      include InstanceMethods
+
+      after_commit :mr_after_commit_call_procs_for_create,  :on => :create
+      after_commit :mr_after_commit_call_procs_for_update,  :on => :update
+      after_commit :mr_after_commit_call_procs_for_destroy, :on => :destroy
+    end
+
+    module InstanceMethods
+
+      private
+
+      # ActiveRecord runs `after_save` after `after_create`, so run the save
+      # procs after the create procs
+      def mr_after_commit_call_procs_for_create
+        mr_after_commit_call_procs(:create)
+        mr_after_commit_call_procs(:save)
+      end
+
+      # ActiveRecord runs `after_save` after `after_update`, so run the save
+      # procs after the update procs
+      def mr_after_commit_call_procs_for_update
+        mr_after_commit_call_procs(:update)
+        mr_after_commit_call_procs(:save)
+      end
+
+      def mr_after_commit_call_procs_for_destroy
+        mr_after_commit_call_procs(:destroy)
+      end
+
+    end
+
+  end
+
+end

data/lib/mr/after_commit/record_procs_methods.rb

@@ -0,0 +1,82 @@
+module MR; end
+module MR::AfterCommit
+
+  module RecordProcsMethods
+
+    VALID_CALLBACK_TYPES = [
+      :create,
+      :update,
+      :save,
+      :destroy
+    ].freeze
+
+    DEFAULT_CALLBACK_TYPE = :save.freeze
+
+    # these methods are used by the `Record` and `FakeRecord` mixins
+
+    def after_commit_procs(*keys)
+      if keys.empty?
+        mr_after_commit_procs_hash.values.flatten
+      else
+        keys.map{ |k| mr_after_commit_procs_hash[k.to_sym] }.flatten
+      end
+    end
+
+    def add_after_commit_proc(callback_type = nil, &block)
+      callback_type ||= DEFAULT_CALLBACK_TYPE
+      mr_after_commit_procs_hash[callback_type.to_sym] << block
+    end
+
+    def prepend_after_commit_proc(callback_type = nil, &block)
+      callback_type ||= DEFAULT_CALLBACK_TYPE
+      mr_after_commit_procs_hash[callback_type.to_sym].unshift(block)
+    end
+
+    def clear_after_commit_procs(*keys)
+      if keys.empty?
+        mr_after_commit_procs_hash.clear
+      else
+        keys.map{ |k| mr_after_commit_procs_hash.delete(k.to_sym) }
+      end
+    end
+
+    def called_after_commit_procs(*keys)
+      if keys.empty?
+        mr_after_commit_called_procs_hash.values.flatten
+      else
+        keys.map{ |k| mr_after_commit_called_procs_hash[k.to_sym] }.flatten
+      end
+    end
+
+    private
+
+    def mr_after_commit_call_procs(callback_type)
+      procs = self.after_commit_procs(callback_type)
+      procs.each(&:call)
+      mr_after_commit_called_procs_hash[callback_type] += procs
+      self.clear_after_commit_procs(callback_type)
+    end
+
+    def mr_after_commit_procs_hash
+      @mr_after_commit_procs_hash ||= MR::AfterCommit::CallbackProcsHash.new
+    end
+
+    def mr_after_commit_called_procs_hash
+      @mr_after_commit_called_procs_hash ||= MR::AfterCommit::CallbackProcsHash.new
+    end
+
+  end
+
+  module CallbackProcsHash
+    def self.new
+      Hash.new do |h, k|
+        if !VALID_CALLBACK_TYPES.include?(k)
+          raise ArgumentError, "#{k.inspect} is not a valid callback " \
+                               "type, use: #{VALID_CALLBACK_TYPES.join(', ')}"
+        end
+        h[k] = []
+      end
+    end
+  end
+
+end

data/lib/mr/factory.rb

@@ -0,0 +1,82 @@
+require 'assert/factory'
+require 'thread'
+require 'mr/factory/model_factory'
+require 'mr/factory/read_model_factory'
+require 'mr/factory/record_factory'
+require 'mr/type_converter'
+
+module MR
+
+  module Factory
+    extend Assert::Factory
+    extend self
+
+    def new(object_class, *args, &block)
+      if object_class < MR::Model
+        ModelFactory.new(object_class, *args, &block)
+      elsif object_class < MR::ReadModelStruct
+        ReadModelFactory.new(object_class, *args, &block)
+      elsif object_class < MR::Record
+        RecordFactory.new(object_class, *args, &block)
+      else
+        raise ArgumentError, "takes a MR::Model, MR::Record, or MR::ReadModel"
+      end
+    end
+
+    def primary_key(identifier = nil)
+      identifier    ||= 'MR::Factory'
+      @primary_keys ||= {}
+      @primary_keys[identifier.to_s] ||= PrimaryKeyProvider.new
+      self.type_cast(@primary_keys[identifier.to_s].next, :primary_key)
+    end
+
+    def decimal(max = nil)
+      self.type_cast(Assert::Factory::Random.float(max), :decimal)
+    end
+
+    def timestamp
+      self.datetime
+    end
+
+    def type_converter
+      @type_converter ||= MR::TypeConverter.new
+    end
+
+    class PrimaryKeyProvider
+      attr_reader :mutex, :current
+      def initialize
+        @current = 0
+        @mutex   = Mutex.new
+      end
+      def next
+        @mutex.synchronize{ @current += 1 }
+      end
+    end
+
+    # used by factories and stacks to say they can't determine a record class for
+    # an association (usually a polymorphic association doesn't have its foreign
+    # type attribute set)
+    class NoRecordClassError < RuntimeError
+      def self.for_association(ar_association)
+        owner_record_class = ar_association.owner.class
+        association_name   = ar_association.reflection.name
+        message = "can't build '#{association_name}' association on " \
+                  "#{owner_record_class}"
+        if ar_association.reflection.options[:polymorphic]
+          foreign_type_attribute = ar_association.reflection.foreign_type
+          message += " -- try manually setting it, building it via a stack " \
+                     "if you've configured default associations, or setting " \
+                     "its '#{foreign_type_attribute}' attribute"
+        else
+          message += " -- try manually setting it or building it via a stack " \
+                     "if you've configured default associations"
+        end
+        self.new(message)
+      end
+    end
+
+    NoAssociationError = Class.new(ArgumentError)
+
+  end
+
+end

data/lib/mr/factory/config.rb

@@ -0,0 +1,240 @@
+require 'much-plugin'
+
+module MR; end
+module MR::Factory
+
+  module Config
+    include MuchPlugin
+
+    plugin_included do
+      include InstanceMethods
+    end
+
+    module InstanceMethods
+
+      attr_reader :object_class
+
+      def initialize(object_class)
+        @object_class = object_class
+      end
+
+      # make the methods lazy-eval'd so factories can be built without paying
+      # the performance of them building out their config, this makes it less
+      # costly to require real and fake factories together in a test suite
+      # (i.e. we don't want to split our real and fake factories into separate
+      # files)
+
+      def apply_args(object, args)
+        apply_default_args(object)
+        apply_args_from_hash(object, args)
+        true
+      end
+
+      def set_default_args(&block)
+        @default_args_proc = block
+      end
+
+      private
+
+      def object_builder_class; ObjectBuilder; end
+
+      def apply_default_args(object)
+        apply_args_from_proc(object, &@default_args_proc) if @default_args_proc
+      end
+
+      def apply_args_from_hash(object, args_hash)
+        object_builder_class.apply_hash(object, self, args_hash)
+      end
+
+      def apply_args_from_proc(object, &args_proc)
+        object_builder_class.apply_proc(object, self, &args_proc)
+      end
+
+    end
+
+    class ObjectBuilder
+
+      def self.apply_hash(object, factory_config, hash)
+        self.new(object, factory_config).tap do |builder|
+          hash.each{ |k, v| builder.set(k, v) }
+        end
+      end
+
+      def self.apply_proc(object, factory_config, &proc)
+        self.new(object, factory_config).tap do |builder|
+          builder.instance_eval(&proc)
+        end
+      end
+
+      def initialize(object, factory_config)
+        @__mr_ob_object         = object
+        @__mr_ob_factory_config = factory_config
+      end
+
+      def set(name, value)
+        __mr_ob_set_attribute(@__mr_ob_object, name, value)
+      rescue ArgumentError => exception
+        exception.set_backtrace(caller)
+        raise exception
+      end
+
+      private
+
+      def __mr_ob_set_attribute(object, name, value)
+        object.send("#{name}=", value)
+      end
+    end
+
+  end
+
+  module WithAssociationsConfig
+    include MuchPlugin
+
+    plugin_included do
+      include MR::Factory::Config
+      include InstanceMethods
+    end
+
+    module InstanceMethods
+
+      def record_class
+        self.object_class
+      end
+
+      def force_in_stack_association_names
+        @force_in_stack_association_names ||= []
+      end
+
+      def force_in_stack_association?(association_name)
+        self.force_in_stack_association_names.include?(association_name)
+      end
+
+      def default_factories
+        @default_factories ||= Hash.new do |h, record_class|
+          # raise a no record class error if passed a `nil` record class, this
+          # can happen when a polymorphic association is passed to `factory_for`
+          # and its foreign type attribute isn't set
+          raise NoRecordClassError if record_class.nil?
+          h[record_class] = build_factory_for_record_class(record_class)
+        end
+      end
+
+      def association_factories
+        @association_factories ||= {}
+      end
+
+      def factories_for(association_name, record_class)
+        key = AssociationFactoriesKey.new(association_name, record_class)
+        self.association_factories[key] || [self.default_factories[record_class]]
+      end
+
+      def factory_for(association_name, record_class)
+        self.factories_for(association_name, record_class).sample
+      end
+
+      def factory_config_for(association_name, record_class)
+        self.factory_for(association_name, record_class).config
+      end
+
+      def record_classes_for(association_name)
+        self.factories_for(association_name, nil).map(&:record_class)
+      rescue NoRecordClassError
+        []
+      end
+
+      def build_associated_record(association_name, record_class)
+        raise NotImplementedError
+      end
+
+      def add_association_factory(association_name, factory, options = nil)
+        reflection = self.record_class.reflect_on_association(association_name)
+        if reflection.nil?
+          raise NoAssociationError, "there is no #{association_name.inspect} " \
+                                    "association for #{self.record_class.inspect}"
+        end
+
+        options ||= {}
+        if options[:force_in_stack]
+          (self.force_in_stack_association_names << association_name).uniq!
+        end
+
+        add_default_factory(factory.record_class, factory)
+
+        # for polymorphic associations add a lookup with no associated record
+        # class, this will allow a polymorphic association without their foreign
+        # type attribute set to use the configured factories for the association
+        if reflection.options[:polymorphic]
+          key = AssociationFactoriesKey.new(association_name)
+          add_association_factory_by_key(key, factory)
+        end
+
+        key = AssociationFactoriesKey.new(association_name, factory.record_class)
+        add_association_factory_by_key(key, factory)
+      end
+
+      def ar_association_for(object, name)
+        raise NotImplementedError
+      end
+
+      private
+
+      def object_builder_class; WithAssociationsConfig::ObjectBuilder; end
+
+      def build_factory_for_record_class(record_class)
+        raise NotImplementedError
+      end
+
+      def add_association_factory_by_key(key, factory)
+        self.association_factories[key] = [] if !self.association_factories.key?(key)
+        self.association_factories[key] << factory
+      end
+
+      def add_default_factory(record_class, factory)
+        if !self.default_factories.key?(record_class)
+          self.default_factories[record_class] = factory
+        end
+      end
+
+    end
+
+    class ObjectBuilder < MR::Factory::Config::ObjectBuilder
+
+      def set(name, value)
+        if value.kind_of?(Hash) && (association = __mr_ob_get_association(name))
+          __mr_ob_set_association_from_hash(association, name, value)
+        else
+          super(name, value)
+        end
+      rescue ArgumentError, NoRecordClassError => exception
+        exception.set_backtrace(caller)
+        raise exception
+      end
+
+      private
+
+      def __mr_ob_get_association(name)
+        @__mr_ob_factory_config.ar_association_for(@__mr_ob_object, name)
+      end
+
+      def __mr_ob_set_association_from_hash(association, name, value)
+        factory = begin
+          @__mr_ob_factory_config.factory_for(name, association.klass)
+        rescue NoRecordClassError
+          raise NoRecordClassError.for_association(association)
+        end
+        associated_object = @__mr_ob_object.send(name) || factory.instance
+        self.class.apply_hash(associated_object, factory.config, value)
+        __mr_ob_set_attribute(@__mr_ob_object, name, associated_object)
+      end
+
+    end
+
+    module AssociationFactoriesKey
+      def self.new(association_name, associated_record_class = nil)
+        [association_name, associated_record_class].compact.join("-")
+      end
+    end
+
+  end
+
+end