mr 0.35.2

data/lib/mr/factory/model_factory.rb

@@ -0,0 +1,103 @@
+require 'mr/factory'
+require 'mr/factory/config'
+require 'mr/factory/model_stack'
+require 'mr/factory/record_factory'
+require 'mr/fake_record'
+
+module MR; end
+module MR::Factory
+
+  class ModelFactory
+
+    attr_reader :model_class, :record_class, :config
+
+    def initialize(model_class, record_class, &block)
+      @model_class  = model_class
+      @record_class = record_class
+      @config       = Config.new(@record_class)
+      self.instance_eval(&block) if block
+
+      @record_factory = MR::Factory::RecordFactory.new(record_class)
+    end
+
+    def model(args = nil)
+      @model_class.new(@record_factory.record).tap do |model|
+        self.config.apply_args(model, args || {})
+      end
+    end
+    alias :instance :model
+
+    def saved_model(args = nil)
+      model = self.model(args).tap(&:save)
+      model.record.reset_save_called if model.record.kind_of?(MR::FakeRecord)
+      model
+    end
+    alias :saved_instance :saved_model
+
+    def stack(args = nil)
+      MR::Factory::ModelStack.new(self.model(args), self.config)
+    end
+    alias :instance_stack :stack
+
+    def stack_model(args = nil)
+      self.stack(args).model
+    end
+
+    def saved_stack(args = nil)
+      self.stack(args).tap(&:create)
+    end
+
+    def saved_stack_model(args = nil)
+      self.saved_stack(args).model
+    end
+
+    def saved_dependencies_stack(args = nil)
+      self.stack(args).tap(&:create_deps)
+    end
+    alias :saved_deps_stack :saved_dependencies_stack
+
+    def saved_dependencies_stack_model(args = nil)
+      self.saved_deps_stack(args).model
+    end
+    alias :saved_deps_stack_model :saved_dependencies_stack_model
+
+    private
+
+    def default_association(association_name, factory, options = nil)
+      self.config.add_association_factory(association_name, factory, options)
+    rescue NoAssociationError => exception
+      raise exception.class, exception.message, caller
+    end
+
+    def default_args(&block)
+      self.config.set_default_args(&block)
+    end
+
+    class Config
+      include MR::Factory::WithAssociationsConfig
+
+      def build_associated_model(association_name, record_class)
+        self.factory_for(association_name, record_class).model
+      end
+
+      def build_associated_record(association_name, record_class)
+        self.build_associated_model(association_name, record_class).record
+      end
+
+      def ar_association_for(model, name)
+        if (reflection = model.record_class.reflect_on_association(name))
+          model.record.association(reflection.name)
+        end
+      end
+
+      private
+
+      def build_factory_for_record_class(record_class)
+        MR::Factory::ModelFactory.new(record_class.model_class, record_class)
+      end
+    end
+
+  end
+
+
+end

data/lib/mr/factory/model_stack.rb

@@ -0,0 +1,28 @@
+require 'mr/factory/record_factory'
+require 'mr/factory/record_stack'
+
+module MR; end
+module MR::Factory
+
+  class ModelStack
+
+    attr_reader :model
+
+    def initialize(model, factory_config)
+      @model        = model
+      @record_stack = MR::Factory::RecordStack.for_record(model.record, factory_config)
+    end
+
+    def factory_config; @record_stack.factory_config; end
+
+    def create;  @record_stack.create;  end
+    def destroy; @record_stack.destroy; end
+
+    def create_dependencies; @record_stack.create_dependencies; end
+    alias :create_deps :create_dependencies
+
+    def destroy_dependencies; @record_stack.destroy_dependencies; end
+    alias :destroy_deps :destroy_dependencies
+  end
+
+end

data/lib/mr/factory/read_model_factory.rb

@@ -0,0 +1,104 @@
+require 'mr/factory'
+require 'mr/factory/config'
+require 'mr/read_model'
+
+module MR; end
+module MR::Factory
+
+  class ReadModelFactory
+
+    attr_reader :read_model_class, :config
+
+    def initialize(read_model_class, &block)
+      unless read_model_class < MR::ReadModelStruct
+        raise ArgumentError, "takes a read model or read model struct"
+      end
+      @read_model_class = read_model_class
+      @config           = Config.new(read_model_class)
+      self.instance_eval(&block) if block
+    end
+
+    def read_model_data(args = nil)
+      Data.new.tap do |read_model_data|
+        self.config.apply_args(read_model_data, args || {})
+      end
+    end
+
+    def read_model(args = nil)
+      @read_model_class.new(self.read_model_data(args))
+    end
+    alias :instance :read_model
+
+    private
+
+    def default_args(&block)
+      self.config.set_default_args(&block)
+    end
+
+    class Config
+      include MR::Factory::Config
+
+      def read_model_class
+        self.object_class
+      end
+
+      private
+
+      def apply_default_args(data)
+        field_defaults.each do |field_name, field_type|
+          data[field_name] = MR::Factory.send(field_type)
+        end
+        json_struct_list_defaults.each do |field_name, factory|
+          data[field_name] = Factory.integer(3).times.map{ factory.read_model_data }
+        end
+        json_struct_obj_defaults.each do |field_name, factory|
+          data[field_name] = factory.read_model_data
+        end
+        super(data)
+      end
+
+      def field_defaults
+        @field_defaults ||= self.read_model_class.fields.inject({}) do |h, field|
+          h.merge!(field.name.to_s => field.type)
+        end
+      end
+
+      def json_struct_list_defaults
+        @json_struct_list_defaults ||= build_defaults_for_json_struct_fields(
+          self.read_model_class.json_struct_lists
+        )
+      end
+
+      def json_struct_obj_defaults
+        @json_struct_obj_defaults ||= build_defaults_for_json_struct_fields(
+          self.read_model_class.json_struct_objs
+        )
+      end
+
+      def build_defaults_for_json_struct_fields(fields)
+        fields.inject({}) do |h, field|
+          factory = MR::Factory::ReadModelFactory.new(field.struct_class)
+          h.merge!(field.name.to_s => factory)
+        end
+      end
+    end
+
+    class Data
+      def initialize; @hash = {}; end
+
+      def [](key);         @hash[key];         end
+      def []=(key, value); @hash[key] = value; end
+
+      def method_missing(method, *args, &block)
+        method_string = method.to_s
+        if method_string =~ /=\z/ && args.size == 1
+          @hash[method_string.gsub('=', '')] = args.first
+        else
+          super
+        end
+      end
+    end
+
+  end
+
+end

data/lib/mr/factory/record_factory.rb

@@ -0,0 +1,130 @@
+require 'mr/factory'
+require 'mr/factory/config'
+require 'mr/factory/record_stack'
+require 'mr/fake_record'
+
+module MR; end
+module MR::Factory
+
+  class RecordFactory
+
+    attr_reader :record_class, :config
+
+    def initialize(record_class, &block)
+      @record_class = record_class
+      @config       = Config.new(record_class)
+      self.instance_eval(&block) if block
+    end
+
+    def record(args = nil)
+      @record_class.new.tap do |record|
+        self.config.apply_args(record, args || {})
+      end
+    end
+    alias :instance :record
+
+    def saved_record(args = nil)
+      record = self.record(args).tap(&:save!)
+      record.reset_save_called if record.kind_of?(MR::FakeRecord)
+      record
+    end
+    alias :saved_instance :saved_record
+
+    def stack(args = nil)
+      MR::Factory::RecordStack.for_record(self.record(args), self.config)
+    end
+    alias :instance_stack :stack
+
+    def stack_record(args = nil)
+      self.stack(args).record
+    end
+
+    def saved_stack(args = nil)
+      self.stack(args).tap(&:create)
+    end
+
+    def saved_stack_record(args = nil)
+      self.saved_stack(args).record
+    end
+
+    def saved_dependencies_stack(args = nil)
+      self.stack(args).tap(&:create_deps)
+    end
+    alias :saved_deps_stack :saved_dependencies_stack
+
+    def saved_dependencies_stack_record(args = nil)
+      self.saved_deps_stack(args).record
+    end
+    alias :saved_deps_stack_record :saved_dependencies_stack_record
+
+    private
+
+    def default_association(association_name, factory, options = nil)
+      self.config.add_association_factory(association_name, factory, options)
+    rescue NoAssociationError => exception
+      raise exception.class, exception.message, caller
+    end
+
+    def default_args(&block)
+      self.config.set_default_args(&block)
+    end
+
+    class Config
+      include MR::Factory::WithAssociationsConfig
+
+      def build_associated_record(association_name, record_class)
+        self.factory_for(association_name, record_class).record
+      end
+
+      def ar_association_for(record, name)
+        if (reflection = record.class.reflect_on_association(name))
+          record.association(reflection.name)
+        end
+      end
+
+      private
+
+      def apply_default_args(record)
+        column_defaults.each do |column_name, column_type|
+          record.send("#{column_name}=", MR::Factory.send(column_type))
+        end
+        super(record)
+      end
+
+      def build_factory_for_record_class(record_class)
+        MR::Factory::RecordFactory.new(record_class)
+      end
+
+      def column_defaults
+        @column_defaults ||= begin
+          association_column_names = association_column_names(self.record_class)
+          self.record_class.columns.inject({}) do |args, column|
+            column_type = column.type || column.sql_type
+            if should_default_column?(column, association_column_names, column_type)
+              args[column.name.to_s] = column_type
+            end
+            args
+          end
+        end
+      end
+
+      def should_default_column?(column, association_column_names, column_type)
+        !column.primary                                 &&
+        !association_column_names.include?(column.name) &&
+        !column_type.nil?                               &&
+        MR::Factory.respond_to?(column_type)
+      end
+
+      def association_column_names(record_class)
+        names = []
+        record_class.reflect_on_all_associations(:belongs_to).each do |reflection|
+          names << reflection.foreign_type if reflection.options[:polymorphic]
+          names << reflection.foreign_key
+        end
+        names
+      end
+    end
+
+  end
+
+end

data/lib/mr/factory/record_stack.rb

@@ -0,0 +1,219 @@
+require 'mr/factory'
+require 'mr/fake_record'
+
+module MR; end
+module MR::Factory
+
+  class RecordStack
+
+    def self.for_record(record, factory_config)
+      self.new(RecordData.new(record), factory_config)
+    end
+
+    attr_reader :record_data, :factory_config, :record_lookup
+    attr_reader :record_stacks
+
+    def initialize(record_data, factory_config, record_lookup = nil)
+      @record_data    = record_data
+      @factory_config = factory_config
+      @record_lookup  = record_lookup || build_lookup(@record_data)
+
+      @record_stacks = @record_data.association_datas.map do |association_data|
+        next unless association_data.required?(factory_config)
+
+        associated_record_data = association_data.get_record_data(
+          @factory_config,
+          @record_lookup
+        )
+        associated_factory_config = @factory_config.factory_config_for(
+          association_data.name,
+          associated_record_data.record_class
+        )
+        @record_lookup[associated_record_data.record_class] ||= associated_record_data
+        @record_data.set_association(association_data.name, associated_record_data)
+        MR::Factory::RecordStack.new(
+          associated_record_data,
+          associated_factory_config,
+          @record_lookup
+        )
+      end.compact
+    end
+
+    def record
+      self.record_data.record
+    end
+
+    def create
+      self.create_dependencies
+      self.record_data.create_record
+      true
+    end
+
+    def destroy
+      self.record_data.destroy_record
+      self.destroy_dependencies
+      true
+    end
+
+    def create_dependencies
+      self.record_stacks.each(&:create)
+      self.record_data.refresh_record_associations
+      true
+    end
+    alias :create_deps :create_dependencies
+
+    def destroy_dependencies
+      self.record_stacks.each(&:destroy)
+      true
+    end
+    alias :destroy_deps :destroy_dependencies
+
+    private
+
+    def build_lookup(record_data)
+      load_preset_associations_into_lookup({}, record_data)
+    end
+
+    def load_preset_associations_into_lookup(lookup, record_data)
+      record_data.association_datas.select(&:preset?).each do |association_data|
+        preset_record_data = association_data.preset_record_data
+        lookup[preset_record_data.record_class] ||= preset_record_data
+        load_preset_associations_into_lookup(lookup, preset_record_data)
+      end
+      lookup
+    end
+
+    class RecordData
+
+      attr_reader :record, :association_datas
+
+      def initialize(record)
+        @record            = record
+        @association_datas = build_association_datas(@record)
+      end
+
+      def record_class
+        @record.class
+      end
+
+      def set_association(name, record_data)
+        @record.send("#{name}=", record_data.record)
+      end
+
+      def create_record
+        if @record.new_record?
+          @record.save!
+          @record.reset_save_called if @record.kind_of?(MR::FakeRecord)
+        end
+      end
+
+      def destroy_record
+        @record.destroy unless @record.destroyed?
+      end
+
+      # ensures records have their associations foreign type/key attributes set
+      # by re-setting the association to its current value
+      def refresh_record_associations
+        @association_datas.each do |association_data|
+          associated_record = @record.send(association_data.name)
+          @record.send("#{association_data.name}=", associated_record)
+        end
+      end
+
+      private
+
+      def build_association_datas(record)
+        record.class.reflect_on_all_associations(:belongs_to).map do |reflection|
+          AssociationData.new(record.association(reflection.name))
+        end.compact.sort
+      end
+
+    end
+
+    class AssociationData
+
+      attr_reader :association, :preset_record_data
+
+      def initialize(association)
+        @association = association
+
+        preset_record = association.owner.send("#{self.name}")
+        @preset_record_data = RecordData.new(preset_record) if preset_record
+      end
+
+      def name
+        self.association.reflection.name
+      end
+
+      def record_class
+        self.association.klass
+      end
+
+      def preset?
+        !self.preset_record_data.nil?
+      end
+
+      def required?(factory_config)
+        self.preset?                                      ||
+        factory_config.force_in_stack_association?(self.name) ||
+        columns_required?(self.association)
+      end
+
+      def get_record_data(factory_config, lookup)
+        if self.preset?
+          self.preset_record_data
+        elsif (lookup_record_data = get_lookup_record_data(factory_config, lookup))
+          lookup_record_data
+        else
+          RecordData.new(build_record(factory_config))
+        end
+      end
+
+      def <=>(other)
+        if other.kind_of?(self.class)
+          self.name.to_s <=> other.name.to_s
+        else
+          super
+        end
+      end
+
+      private
+
+      # get the intersection of the record classes and use a random match to
+      # get a record data from the lookup; if their are no matching record
+      # classes the intersection returns an empty array which will return a
+      # `nil` value from the lookup
+      def get_lookup_record_data(factory_config, lookup)
+        record_classes = lookup_record_classes(factory_config) & lookup.keys
+        lookup[record_classes.sample]
+      end
+
+      def lookup_record_classes(factory_config)
+        if self.record_class
+          [self.record_class]
+        else
+          factory_config.record_classes_for(self.name)
+        end
+      end
+
+      def build_record(factory_config)
+        factory_config.build_associated_record(self.name, self.record_class)
+      rescue NoRecordClassError
+        raise NoRecordClassError.for_association(self.association)
+      end
+
+      def columns_required?(association)
+        column_required?(association.owner, association.reflection.foreign_key)  ||
+        column_required?(association.owner, association.reflection.foreign_type)
+      end
+
+      def column_required?(record, column_name)
+        column = record.column_for_attribute(column_name)
+        !(column.nil? || column.null)
+      end
+
+    end
+
+  end
+
+end