sample_models 1.2.6 → 2.0.0

data/lib/sample_models/creation.rb

@@ -1,126 +1,173 @@
+require 'delegate'
+
 module SampleModels
   class Creation
-    def initialize(sampler, attrs)
+    def initialize(sampler, *args)
       @sampler = sampler
-      @orig_attrs = SampleModels.hash_with_indifferent_access_class.new attrs
-      @attrs = Attributes.new(@sampler, attrs)
+      @specified_attrs = SpecifiedAttributes.new(sampler, *args).result
     end
     
-    def model
-      SampleModels.models[@sampler.model_class]
+    def belongs_to_assoc(column_name)
+      model.belongs_to_associations.detect { |assoc|
+        assoc.foreign_key == column_name
+      }
     end
     
-    def polymorphic_assoc_value(assoc)
-      if klass = @sampler.polymorphic_default_classes[assoc.name]
-        klass.sample
-      else
-        SampleModels.samplers.values.map(&:model_class).detect { |m|
-          m != @sampler.model_class
-        }.sample
+    def deferred_belongs_to_assocs
+      @deferred_belongs_to_assocs ||= begin
+        model.belongs_to_associations.select { |a|
+          @instance.send(a.foreign_key).nil? &&
+            !@specified_attrs.member?(a.foreign_key) &&
+            !@specified_attrs.member?(a.name) && 
+            !@sampler.defaults.member?(a.foreign_key) &&
+            !@sampler.defaults.member?(a.name)
+        }
       end
     end
     
+    def model
+      @sampler.model
+    end
+    
     def run
-      @instance = @sampler.model_class.new @attrs.to_hash
+      attrs = @specified_attrs.clone
+      @sampler.defaults.each do |attr, val|
+        attrs[attr] = val unless attrs.member?(attr)
+      end
+      columns_to_fill = model.columns.clone
+      model.validated_attr_accessors.each do |attr|
+        columns_to_fill << VirtualColumn.new(attr)
+      end
+      columns_to_fill.each do |column|
+        unless attrs.member?(column.name) || 
+               specified_association_value?(column.name) ||
+               ((assoc = belongs_to_assoc(column.name)) && attrs.member?(assoc.name)) || timestamp?(column.name)
+          sequence = @sampler.first_pass_attribute_sequence(column)
+          attrs[column.name] = sequence.value
+        end
+      end
+      @instance = model.new(attrs)
       save!
-      update_associations
+      update_with_deferred_associations!
       @instance
     end
     
     def save!
-      @sampler.save!(@instance, @orig_attrs)
-    end
-    
-    def update_associations
-      needs_another_save = false
-      model.belongs_to_associations.each do |assoc|
-        unless @instance.send(assoc.name) || @attrs.has_key?(assoc.name) ||
-               @attrs.has_key?(assoc.association_foreign_key)
-          if assoc.options[:polymorphic]
-            needs_another_save = true
-            @instance.send "#{assoc.name}=", polymorphic_assoc_value(assoc)
-          elsif @sampler.model_class != assoc.klass
-            needs_another_save = true
-            @instance.send "#{assoc.name}=", assoc.klass.sample
-          end
+      if @sampler.before_save
+        if @sampler.before_save.arity == 1
+          @sampler.before_save.call(@instance)
+        else
+          @sampler.before_save.call(@instance, @specified_attrs)
         end
       end
-      save! if needs_another_save
+      @instance.save!
     end
     
-    class Attributes < SampleModels.hash_with_indifferent_access_class
-      def initialize(sampler, hash)
-        @sampler = sampler
-        hash = Sampler.reify_association_hashes model, hash
-        super(hash)
-        fill_based_on_validations
-        fill_based_on_configured_defaults
-        model.columns.each do |column|
-          unless has_key?(column.name)
-            fill_based_on_column_type column
-          end
+    def specified_association_value?(column_name)
+      @specified_attrs.any? { |attr, val|
+        if assoc = model.belongs_to_association(attr)
+          assoc.foreign_key == column_name
         end
-      end
-    
-      def model
-        SampleModels.models[@sampler.model_class]
-      end
+      }
+    end
     
-      def fill_based_on_column_type(column)
-        case column.type
-        when :string
-          fill_based_on_string_column_type(column)
-        when :integer
-          unless model.belongs_to_associations.any? { |assoc|
-            foreign_key = if assoc.respond_to?(:foreign_key)
-              assoc.foreign_key
-            else
-              assoc.primary_key_name
-            end
-            foreign_key == column.name
-          }
-            self[column.name] = 1
+    def timestamp?(column_name)
+      %w(created_at updated_at created_on updated_on).include?(column_name)
+    end
+  
+    def update_with_deferred_associations!
+      unless deferred_belongs_to_assocs.empty?
+        deferred_belongs_to_assocs.each do |a|
+          if a.polymorphic?
+            klass = @sampler.polymorphic_default_classes[a.name]
+            klass ||= SampleModels.samplers.values.map(&:model).detect { |m|
+              m != @sampler.model
+            }
+            @instance.send("#{a.name}=", klass.sample)
+          else
+            column = model.columns.detect { |c| c.name == a.foreign_key }
+            @instance.send(
+              "#{a.foreign_key}=", 
+              @sampler.second_pass_attribute_sequence(column).next
+            )
           end
-        when :datetime
-          self[column.name] = Time.now.utc
-        when :float
-          self[column.name] = 1.0
         end
+        save!
       end
+    end
     
-      def fill_based_on_configured_defaults
-        @sampler.configured_default_attrs.each do |attr, val|
-          self[attr] = val unless has_key?(attr)
+    class SpecifiedAttributes
+      attr_reader :result
+      
+      def initialize(sampler, *args)
+        @sampler = sampler
+        @result = if args.first.is_a?(Symbol)
+          sample_name = args.shift
+          @sampler.named_samples[sample_name].clone
+        else
+          {}
+        end
+        @result.merge!(args.pop) if args.last.is_a?(Hash)
+        args.each do |associated_value|
+          assign_associated_record_from_args(associated_value)
+        end
+        model.belongs_to_associations.each do |assoc|
+          build_belongs_to_record_from_shortcut_args(assoc)
         end
+        model.has_many_associations.each do |assoc|
+          build_has_many_record_from_shortcut_args(assoc)
+        end
+        @result = HashWithIndifferentAccess.new(@result)
       end
-    
-      def fill_based_on_string_column_type(column)
-        unless model.belongs_to_associations.any? { |assoc|
-          assoc.options[:polymorphic] &&
-            assoc.options[:foreign_type] = column.name
+      
+      def assign_associated_record_from_args(associated_value)
+        assocs = model.associations.select { |a|
+          begin
+            a.klass == associated_value.class
+          rescue NameError
+            false
+          end
         }
-          self[column.name] = "#{column.name}"
+        if assocs.size == 1
+          @result[assocs.first.name] = associated_value
+        else
+          raise "Not sure what to do with associated value #{associated_value.inspect}"
         end
       end
-    
-      def fill_based_on_validations
-        model.validation_collections.each do |field, validation_collection|
-          assoc_key = nil
-          if assoc = model.belongs_to_associations.detect { |a|
-            foreign_key = if a.respond_to?(:foreign_key)
-              a.foreign_key
-            else
-              a.primary_key_name
-            end
-            foreign_key == field.to_s
-          }
-            assoc_key = assoc.name
-          end
-          unless has_key?(field) || (assoc_key && has_key?(assoc_key))
-            self[field] = validation_collection.satisfying_value
+      
+      def build_belongs_to_record_from_shortcut_args(assoc)
+        if value = @result[assoc.name]
+          if value.is_a?(Hash)
+            @result[assoc.name] = assoc.klass.sample(value)
+          elsif value.is_a?(Array)
+            @result[assoc.name] = assoc.klass.sample(*value)
           end
         end
       end
+      
+      def build_has_many_record_from_shortcut_args(assoc)
+        if values = @result[assoc.name]
+          @result[assoc.name] = values.map { |value|
+            value.is_a?(Hash) ? assoc.klass.sample(value) : value
+          }
+        end
+      end
+      
+      def model
+        @sampler.model
+      end
+    end
+
+    class VirtualColumn
+      attr_reader :name
+      
+      def initialize(name)
+        @name = name
+      end
+      
+      def type
+        :string
+      end
     end
   end
 end

data/lib/sample_models/initializer.rb

@@ -0,0 +1,48 @@
+module SampleModels
+  class Initializer
+    def run
+      ActiveRecord::Base.send(:include, SampleModels)
+      intercept_validation_definitions
+    end
+  
+    def intercept_validation_definition(validation, recipient)
+      method_name = "#{validation}_with_sample_models".to_sym
+      recipient.send(:define_method, method_name) do |*args|
+        send "#{validation}_without_sample_models".to_sym, *args
+        SampleModels.models[self].record_validation(validation, *args)
+      end
+      recipient.alias_method_chain validation, :sample_models
+    end
+    
+    def intercept_validation_definitions
+      validations_to_intercept = [
+        :validates_email_format_of, :validates_inclusion_of,
+        :validates_presence_of, :validates_uniqueness_of
+      ]
+      optional_interceptions = [:validates_email_format_of]
+      validations_to_intercept.each do |validation|
+        recipient = validation_recipients.detect { |vr|
+          vr.method_defined?(validation)
+        }
+        if recipient
+          intercept_validation_definition(validation, recipient)
+        else
+          unless optional_interceptions.include?(validation)
+            raise "Can't find who defines the validation method #{validation}"
+          end
+        end
+      end
+    end
+    
+    def validation_recipients
+      validation_recipients = [ActiveRecord::Validations::ClassMethods]
+      if Object.const_defined?('ActiveModel')
+        validation_recipients << ActiveModel::Validations::HelperMethods
+      end
+      if Object.const_defined?('ValidatesEmailFormatOf')
+        validation_recipients <<  ValidatesEmailFormatOf::Validations
+      end
+      validation_recipients
+    end
+  end
+end

data/lib/sample_models/model.rb

@@ -2,48 +2,31 @@ require 'delegate'
 
 module SampleModels
   class Model < Delegator
-    attr_reader :validation_collections
+    attr_reader :ar_class
     
-    def initialize(model_class)
-      @model_class = model_class
-      @validation_collections = Hash.new { |h, field|
-        h[field] = ValidationCollection.new(self, field)
-      }
+    def initialize(ar_class)
+      @ar_class = ar_class
+      @validations = Hash.new { |h,k| h[k] = [] }
     end
     
     def __getobj__
-      @model_class
+      @ar_class
     end
     
-    def associations(klass)
-      @model_class.reflect_on_all_associations.select { |a|
-        begin
-          a.klass == klass
-        rescue NameError
-          false
-        end
-      }
+    def associations
+      @ar_class.reflect_on_all_associations.map { |a| Association.new(a) }
     end
     
-    def belongs_to_associations
-      @model_class.reflect_on_all_associations.select { |assoc|
-        assoc.macro == :belongs_to
-      }
+    def belongs_to_association(name)
+      belongs_to_associations.detect { |a| a.name.to_s == name.to_s }
     end
     
-    def construct_finder_sql(*args)
-      if @model_class.method(:scoped).arity == -1 && 
-         @model_class.scoped(nil).respond_to?(:apply_finder_options)
-        @model_class.scoped(nil).apply_finder_options(*args).arel.to_sql
-      else
-        @model_class.send(:construct_finder_sql, *args)
-      end
+    def belongs_to_associations
+      associations.select { |a| a.belongs_to? }
     end
     
     def has_many_associations
-      @model_class.reflect_on_all_associations.select { |assoc|
-        assoc.macro == :has_many
-      }
+      associations.select { |a| a.has_many? }
     end
     
     def record_validation(*args)
@@ -51,145 +34,71 @@ module SampleModels
       config = args.extract_options!
       fields = args
       fields.each do |field|
-        @validation_collections[field].add(type, config)
+        @validations[field.to_s] << Validation.new(type, config)
       end
     end
     
-    def validates_presence_of?(attr)
-      @validation_collections[attr].includes_presence?
+    def unique?(field, value)
+      @ar_class.count(:conditions => {field => value}) == 0
     end
     
-    def unique?(field, value)
-      !@model_class.first(:conditions => {field => value})
+    def validated_attr_accessors
+      @validations.keys.select { |key|
+        columns.none? { |column| column.name.to_s == key.to_s }
+      }
     end
     
-    class ValidationCollection
-      def initialize(model, field)
-        @model, @field = model, field
-        @value_streams = []
-      end
-      
-      def add(validation_method, config)
-        stream_class_name = validation_method.to_s.camelize + 'ValueStream'
-        if ValidationCollection.const_defined?(stream_class_name)
-          stream_class = ValidationCollection.const_get(stream_class_name)
-          if stream_class == ValidatesUniquenessOfValueStream
-            @validates_uniqueness_config = config
-          else
-            input = @value_streams.last
-            @value_streams << stream_class.new(@model, @field, config, input)
-          end
-        end
+    def validations(name)
+      @validations[name.to_s]
+    end
+    
+    class Association < Delegator
+      def initialize(assoc)
+        @assoc = assoc
       end
       
-      def includes_presence?
-        @value_streams.any? { |vs| vs.is_a?(ValidatesPresenceOfValueStream) }
+      def __getobj__
+        @assoc
       end
       
-      def includes_uniqueness?
-        @value_streams.any? { |vs| vs.is_a?(ValidatesUniquenessOfValueStream) }
+      def belongs_to?
+        @assoc.macro == :belongs_to
       end
       
-      def satisfying_value
-        if @validates_uniqueness_config
-          input = @value_streams.last
-          @value_streams << ValidatesUniquenessOfValueStream.new(
-            @model, @field, @validates_uniqueness_config, input
-          )
-          @validates_uniqueness_config = nil
+      def foreign_key
+        if @assoc.respond_to?(:foreign_key)
+          @assoc.foreign_key
+        else
+          @assoc.primary_key_name
         end
-        @value_streams.last.satisfying_value if @value_streams.last
       end
       
-      class ValueStream
-        attr_reader :input
-        
-        def initialize(model, field, config, input)
-          @model, @field, @config, @input = model, field, config, input
-          @sequence_number = 0
-        end
-      
-        def column
-          @model.columns.detect { |c| c.name == @field.to_s }
-        end
-        
-        def increment
-          @sequence_number += 1
-          input.increment if input
-        end
+      def has_many?
+        @assoc.macro == :has_many
       end
       
-      class ValidatesEmailFormatOfValueStream < ValueStream
-        def satisfying_value
-          "john.doe#{@sequence_number}@example.com"
-        end
+      def polymorphic?
+        @assoc.options[:polymorphic]
       end
+    end
+    
+    class Validation
+      attr_reader :config, :type
       
-      class ValidatesInclusionOfValueStream < ValueStream
-        def satisfying_value
-          @config[:in].first
-        end
+      def initialize(type, config = {})
+        @type, @config = type, config
       end
       
-      class ValidatesPresenceOfValueStream < ValueStream
-        def association
-          @model.belongs_to_associations.detect { |a|
-            a.association_foreign_key.to_sym == @field.to_sym
-          }
-        end
-        
-        def increment
-          if association
-            association.klass.create_sample
-          else
-            super
-          end
-        end
-      
-        def satisfying_associated_value
-          value = association.klass.last || association.klass.sample
-          value = value.id if value
-          value
-        end
+      def email_format?
+        @type == :validates_email_format_of
+      end
       
-        def satisfying_value
-          prev_value = input.satisfying_value if input
-          if association
-            satisfying_associated_value
-          else
-            if prev_value.present?
-              prev_value
-            elsif column && column.type == :date
-              Date.today + @sequence_number
-            elsif column && column.type == :datetime
-              Time.utc(1970, 1, 1) + @sequence_number.days
-            elsif column && column.type == :integer
-              @sequence_number
-            else
-              "#{@field} #{@sequence_number}"
-            end
-          end
-        end
+      def inclusion?
+        @type == :validates_inclusion_of
       end
       
-      class ValidatesUniquenessOfValueStream < ValueStream
-        def satisfying_value
-          value = input.satisfying_value if input
-          unless @config[:allow_nil] && value.nil?
-            unless @config[:allow_blank] && value.blank?
-              if !@model.unique?(@field, value)
-                my_input = input || ValidatesPresenceOfValueStream.new(
-                  @model, @field, nil, @input
-                )
-                until @model.unique?(@field, value)
-                  my_input.increment
-                  value = my_input.satisfying_value
-                end
-              end
-            end
-          end
-          value
-        end
+      def presence?
+        @type == :validates_presence_of
       end
     end
   end