sample_models 1.2.6 → 2.0.0

data/lib/sample_models/sampler.rb

@@ -1,115 +1,91 @@
 module SampleModels
   class Sampler
-    def self.reified_belongs_to_associations(model, attrs)
-      assocs = {}
-      model.belongs_to_associations.each do |assoc|
-        if value = attrs[assoc.name]
-          if value.is_a?(Hash)
-            assocs[assoc.name] = assoc.klass.sample(value)
-          elsif value.is_a?(Array)
-            assocs[assoc.name] = assoc.klass.sample(*value)
-          end
-        end
-      end
-      assocs
+    attr_accessor :before_save, :named_samples, :polymorphic_default_classes
+    attr_reader   :defaults
+    
+    def initialize(model_class)
+      @model_class = model_class
+      @attribute_sequences = Hash.new { |h,k| h[k] = {} }
+      @defaults = HashWithIndifferentAccess.new
+      @forced_unique = []
+      @named_samples = HashWithIndifferentAccess.new
+      @polymorphic_default_classes = HashWithIndifferentAccess.new
     end
     
-    def self.reify_association_hashes(model, attrs)
-      a = attrs.clone
-      reified_belongs_to_associations(model, attrs).each do |name, value|
-        a[name] = value
-      end
-      model.has_many_associations.each do |assoc|
-        if values = a[assoc.name]
-          a[assoc.name] = values.map { |value|
-            value.is_a?(Hash) ? assoc.klass.sample(value) : value
-          }
-        end
+    def attribute_sequence(pass, column)
+      @attribute_sequences[pass][column.name] ||= begin
+        AttributeSequence.build(
+          pass, model, column, @forced_unique.include?(column.name)
+        )
       end
-      a
     end
     
-    attr_accessor :before_save
-    attr_reader   :configured_default_attrs, :model_class, :named_sample_attrs,
-                  :polymorphic_default_classes
-    
-    def initialize(model_class)
-      @model_class = model_class
-      @configured_default_attrs = {}
-      @named_sample_attrs = SampleModels.hash_with_indifferent_access_class.new
-      @polymorphic_default_classes =
-        SampleModels.hash_with_indifferent_access_class.new
+    def configure(block)
+      recipient = ConfigureRecipient.new(self)
+      block.call(recipient)
     end
     
-    def create_sample(*args)
-      attrs = preprocessed_attributes(*args)
-      Creation.new(self, attrs).run
+    def first_pass_attribute_sequence(column)
+      attribute_sequence(:first, column)
     end
     
-    def fix_deleted_associations(instance, orig_attrs)
-      needs_save = false
-      model.belongs_to_associations.each do |assoc|
-        foreign_key = if assoc.respond_to?(:foreign_key)
-          assoc.foreign_key
-        else
-          assoc.primary_key_name
-        end
-        if instance.send(foreign_key) && !instance.send(assoc.name)
-         instance.send("#{assoc.name}=", assoc.klass.sample)
-         needs_save = true
-        end
-      end
-      save!(instance, orig_attrs) if needs_save
+    def force_unique(attr)
+      @forced_unique << attr.to_s
     end
-    
+
     def model
       SampleModels.models[@model_class]
     end
     
-    def preprocessed_attributes(*args)
-      if args.first.is_a?(Symbol)
-        preprocessed_named_sample_attrs(args)
-      else
-        attrs = args.last.is_a?(Hash) ? args.pop : {}
-        args.each do |associated_value|
-          assocs = model.associations(associated_value.class)
-          if assocs.size == 1
-            attrs[assocs.first.name] = associated_value
-          else
-            raise "Not sure what to do with associated value #{associated_value.inspect}"
-          end
-        end
-        attrs
-      end
+    def sample(*args)
+      Creation.new(self, *args).run
     end
     
-    def preprocessed_named_sample_attrs(args)
-      attrs = named_sample_attrs[args.shift]
-      attrs = attrs.merge(args.first) unless args.empty?
-      attrs
+    def second_pass_attribute_sequence(column)
+      attribute_sequence(:second, column)
     end
     
-    def sample(*args)
-      attrs = preprocessed_attributes(*args)
-      instance = Finder.new(model, attrs).instance
-      if instance
-        fix_deleted_associations(instance, attrs)
-      else
-        instance = create_sample attrs
+    class ConfigureRecipient
+      def initialize(sampler)
+        @sampler = sampler
       end
-      instance
-    end
-    
-    def save!(instance, orig_attrs)
-      if @before_save
-        if @before_save.arity == 1
-          @before_save.call instance
+      
+      def method_missing(meth, *args, &block)
+        if @sampler.model.column_names.include?(meth.to_s)
+          Attribute.new(@sampler, meth)
+        elsif @sampler.model.belongs_to_association(meth)
+          Attribute.new(@sampler, meth)
+        elsif @sampler.model.instance_methods.include?(meth.to_s) && 
+              @sampler.model.instance_methods.include?("#{meth.to_s}=")
+          Attribute.new(@sampler, meth)
+        elsif meth.to_s =~ /(.*)_sample$/
+          @sampler.named_samples[$1] = args.first
         else
-          @before_save.call instance, orig_attrs
+          super
+        end
+      end
+
+      def before_save(&proc)
+        @sampler.before_save = proc
+      end
+      
+      class Attribute
+        def initialize(sampler, attribute)
+          @sampler, @attribute = sampler, attribute
+        end
+        
+        def default(default)
+          @sampler.defaults[@attribute] = default
+        end
+        
+        def default_class(dc)
+          @sampler.polymorphic_default_classes[@attribute] = dc
+        end
+        
+        def force_unique
+          @sampler.force_unique(@attribute)
         end
       end
-      instance.save!
     end
   end
 end
-

data/lib/sample_models.rb

@@ -8,119 +8,39 @@ module SampleModels
   @@samplers = Hash.new { |h, model_class|
     h[model_class] = Sampler.new(model_class)
   }
-
-  def self.configure(model_class, opts ={})
-    yield ConfigureRecipient.new(model_class) if block_given?
+  
+  def self.configure(model_class, &block)
+    samplers[model_class].configure(block)
   end
   
-  def self.hash_with_indifferent_access_class
-    HashWithIndifferentAccess
+  def self.init
+    Initializer.new.run
   end
-
+  
   protected
   
-  def self.included( mod )
+  def self.included(mod)
     mod.extend ARClassMethods
     super
   end
-  
-  class ConfigureRecipient
-    def initialize(model_class)
-      @model_class = model_class
-    end
-    
-    def before_save(&proc)
-      sampler.before_save = proc
-    end
-    
-    def method_missing(meth, *args)
-      if meth.to_s =~ /(.*)_sample$/
-        sampler.named_sample_attrs[$1] = args.first
-      else
-        Attribute.new(sampler, meth)
-      end
-    end
-    
-    def sampler
-      SampleModels.samplers[@model_class]
-    end
-    
-    class Attribute
-      def initialize(sampler, attribute)
-        @sampler, @attribute = sampler, attribute
-      end
-      
-      def default_class(dc)
-        @sampler.polymorphic_default_classes[@attribute] = dc 
-      end
-      
-      def default(default)
-        if default.blank? and model.validates_presence_of?(@attribute)
-          raise "#{model.name} requires #{@attribute} to not be blank"
-        else
-          @sampler.configured_default_attrs[@attribute] = default
-        end
-      end
-      
-      def force_unique
-        model.record_validation :validates_uniqueness_of, @attribute
-      end
-      
-      def model
-        SampleModels.models[@sampler.model_class]
-      end
-    end
-  end
-  
+
   module ARClassMethods
     def create_sample(*args)
-      sampler = SampleModels.samplers[self]
-      sampler.create_sample(*args)
+      ActiveSupport::Deprecation.warn("#{self.name}.create_sample is deprecated and will be removed in the next major version of SampleModels. Call #{self.name}.sample instead")
+      sample(*args)
     end
     
     def sample(*args)
-      sampler = SampleModels.samplers[self]
-      sampler.sample(*args)
+      SampleModels.samplers[self].sample(*args)
     end
   end
 end
 
-module ActiveRecord
-  class Base
-    include SampleModels
+Dir.entries(File.dirname(__FILE__) + "/sample_models").each do |entry|
+  if entry =~ /(.*)\.rb$/
+    require "sample_models/#{$1}"
   end
 end
 
-validation_recipients = [ActiveRecord::Validations::ClassMethods]
-if Object.const_defined?('ActiveModel')
-  validation_recipients << ActiveModel::Validations::HelperMethods
-end
-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
-    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
-  else
-    unless optional_interceptions.include?(validation)
-      raise "Can't find who defines the validation method #{validation}"
-    end
-  end
-end
-  
-require "#{File.dirname(__FILE__)}/sample_models/creation"
-require "#{File.dirname(__FILE__)}/sample_models/finder"
-require "#{File.dirname(__FILE__)}/sample_models/model"
-require "#{File.dirname(__FILE__)}/sample_models/sampler"
-require "#{File.dirname(__FILE__)}/../vendor/ar_query/lib/ar_query"
+SampleModels.init
 

data/sample_models.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{sample_models}
-  s.version = "1.2.6"
+  s.version = "2.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Francis Hwang"]
-  s.date = %q{2011-11-18}
+  s.date = %q{2011-11-22}
   s.description = %q{
 A library for making it extremely fast for Rails developers to set up and save ActiveRecord instances when writing test cases. It aims to:
 
@@ -32,28 +32,24 @@ A library for making it extremely fast for Rails developers to set up and save A
     "init.rb",
     "install.rb",
     "lib/sample_models.rb",
+    "lib/sample_models/attribute_sequence.rb",
     "lib/sample_models/creation.rb",
-    "lib/sample_models/finder.rb",
+    "lib/sample_models/initializer.rb",
     "lib/sample_models/model.rb",
     "lib/sample_models/sampler.rb",
     "sample_models.gemspec",
-    "spec/sample_models_spec.rb",
-    "spec_or_test/database.yml",
-    "spec_or_test/setup.rb",
-    "spec_or_test/specs_or_test_cases.rb",
     "tasks/sample_models_tasks.rake",
     "test/db/placeholder",
-    "test/test_sample_models.rb",
-    "uninstall.rb",
-    "vendor/ar_query/MIT-LICENSE",
-    "vendor/ar_query/README",
-    "vendor/ar_query/ar_query.gemspec",
-    "vendor/ar_query/init.rb",
-    "vendor/ar_query/install.rb",
-    "vendor/ar_query/lib/ar_query.rb",
-    "vendor/ar_query/spec/ar_query_spec.rb",
-    "vendor/ar_query/tasks/ar_query_tasks.rake",
-    "vendor/ar_query/uninstall.rb"
+    "test/setup/models.rb",
+    "test/setup/schema.rb",
+    "test/test_helper.rb",
+    "test/unit/belongs_to_test.rb",
+    "test/unit/configuration_test.rb",
+    "test/unit/has_many_through_test.rb",
+    "test/unit/named_sample_test.rb",
+    "test/unit/polymorphic_belongs_to_test.rb",
+    "test/unit/sample_test.rb",
+    "uninstall.rb"
   ]
   s.homepage = %q{http://github.com/fhwang/sample_models}
   s.licenses = ["MIT"]

data/test/setup/models.rb

@@ -0,0 +1,205 @@
+
+class Appointment < ActiveRecord::Base
+  belongs_to :calendar
+  belongs_to :category
+  belongs_to :user
+  
+  validates_presence_of :calendar_id, :user_id
+  validates_uniqueness_of :start_time
+  validate :validate_calendar_has_same_user_id
+  
+  def validate_calendar_has_same_user_id
+    if calendar.user_id != user_id
+      errors.add "Appointment needs same user as the calendar"
+    end
+  end
+end
+
+class BlogPost < ActiveRecord::Base
+  has_many   :blog_post_tags
+  belongs_to :merged_into,
+             :class_name => 'BlogPost', :foreign_key => 'merged_into_id'
+  has_many   :tags, :through => :blog_post_tags
+  belongs_to :user
+  
+  validates_presence_of :body
+  validates_presence_of :title
+  validates_presence_of :user_id
+  
+  attr_accessor :instance_attribute
+end
+
+class BlogPostTag < ActiveRecord::Base
+  belongs_to :blog_post
+  belongs_to :tag
+end
+
+class Bookmark < ActiveRecord::Base
+  belongs_to :bookmarkable, :polymorphic => true
+end
+
+class Calendar < ActiveRecord::Base
+  belongs_to :user
+  
+  validates_presence_of :user_id
+end
+
+class Category < ActiveRecord::Base
+  belongs_to :parent, :class_name => 'Category'
+end
+
+class Comment < ActiveRecord::Base
+end
+
+class Episode < ActiveRecord::Base
+  belongs_to :show
+  
+  validates_presence_of :show_id, :original_air_date
+end
+
+class ExternalUser < ActiveRecord::Base
+end
+
+class Network < ActiveRecord::Base
+end
+
+class Show < ActiveRecord::Base
+  belongs_to :network
+end
+
+class Subscription < ActiveRecord::Base
+  belongs_to :subscribable, :polymorphic => true
+  belongs_to :user
+end
+
+class Tag < ActiveRecord::Base
+  validates_uniqueness_of :tag
+  
+  has_many :blog_post_tags
+  has_many :blog_posts, :through => :blog_post_tags
+end
+
+class Topic < ActiveRecord::Base
+  belongs_to :parent, :class_name => 'Topic'
+  
+  validates_presence_of :parent_id
+end
+
+class User < ActiveRecord::Base
+  belongs_to :favorite_blog_post,
+             :class_name => 'BlogPost', :foreign_key => 'favorite_blog_post_id'
+  belongs_to :external_user
+
+  validates_email_format_of :email
+  validates_inclusion_of    :gender, :in => %w(f m)
+  validates_uniqueness_of   :email, :login, :case_sensitive => false
+  validates_uniqueness_of   :external_user_id, :allow_nil => true
+end
+
+class User2 < ActiveRecord::Base
+  validates_presence_of   :login
+  validates_uniqueness_of :login
+end
+
+class UserWithPassword < ActiveRecord::Base
+  attr_accessor :password
+  
+  validates_presence_of :password
+end
+
+class Video < ActiveRecord::Base
+  belongs_to :show
+  belongs_to :network                
+  belongs_to :episode
+  
+  validate :validate_episode_has_same_show_id
+  
+  def validate_episode_has_same_show_id
+    if episode && episode.show_id != show_id
+      msg = "Video needs same show as the episode; show_id is #{show_id.inspect} while episode.show_id is #{episode.show_id.inspect}"
+      if errors.respond_to?(:add_to_base)
+        errors.add_to_base(msg)
+      else
+        errors[:base] << msg
+      end
+    end
+  end
+end
+
+class VideoFavorite < ActiveRecord::Base
+  belongs_to :video
+  belongs_to :user
+  
+  validates_presence_of :user_id, :video_id
+  validates_uniqueness_of :video_id, :scope => :user_id
+end
+
+class VideoTakedownEvent < ActiveRecord::Base
+  belongs_to :video
+  
+  validates_presence_of   :video_id
+  validates_uniqueness_of :video_id
+end
+     
+SampleModels.configure(Appointment) do |appointment|
+  appointment.before_save do |a|
+    a.user_id = a.calendar.user_id
+  end
+end
+
+SampleModels.configure(BlogPost) do |bp|
+  bp.instance_attribute.default 'I am an instance attribute'
+  bp.published_at.force_unique
+  
+  bp.funny_sample :title => 'Funny haha', :average_rating => 3.0
+end
+
+SampleModels.configure(Category) do |category|
+  category.parent.default nil
+end
+
+SampleModels.configure(Subscription) do |sub|
+  sub.subscribable.default_class BlogPost
+end
+
+SampleModels.configure(Topic) do |topic|
+  topic.parent.default nil
+  
+  topic.before_save do |t, sample_attrs|
+    if t.parent.nil?
+      root = Topic.find_by_root(true)
+      unless root
+        # presumably if you're being this strict about self-parenting, you'd 
+        # hook right into the table's primary key sequence. The logic below 
+        # should work well enough for the test cases though.
+        root = Topic.new(:name => 'Root', :root => true)
+        max_h = Topic.connection.select_one("select max(id) from topics")
+        if max_h['max']
+          root.parent_id = max_h['max'].to_i + 1
+        else
+          root.parent_id = 1
+        end
+        root.save!
+      end
+      t.parent = root
+    end
+  end
+end
+
+SampleModels.configure(User) do |user|
+  user.external_user_id.default nil
+end
+
+SampleModels.configure(Video) do |video|
+  video.before_save do |v, sample_attrs|
+    if v.episode && v.episode.show != v.show
+      if sample_attrs[:show]
+        v.episode.show = v.show
+      else
+        v.show = v.episode.show
+      end
+    end
+  end
+  video.view_count.default 0
+end
+

data/test/setup/schema.rb

@@ -0,0 +1,108 @@
+require 'active_record'
+require 'active_record/base'
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new(
+  File.dirname(__FILE__) + '/../../log/test.log'
+)
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3', :database => 'test/db/test.sqlite3'
+)
+
+silence_stream(STDOUT) do
+  ActiveRecord::Schema.define do
+    create_table 'appointments', :force => true do |appointment|
+      appointment.datetime 'start_time', 'end_time'
+      appointment.integer 'user_id', 'calendar_id', 'category_id'
+    end
+    
+    create_table 'blog_posts', :force => true do |blog_post|
+      blog_post.datetime 'published_at'
+      blog_post.integer 'merged_into_id', 'user_id'
+      blog_post.string  'title'
+      blog_post.float   'average_rating'
+      blog_post.text    'body'
+      blog_post.timestamps
+    end
+    
+    create_table "blog_post_tags", :force => true do |t|
+      t.integer "blog_post_id"
+      t.integer "tag_id"
+    end
+    
+    create_table "bookmarks", :force => true do |t|
+      t.integer "bookmarkable_id"
+      t.string  "bookmarkable_type"
+    end
+
+    create_table 'calendars', :force => true do |calendar|
+      calendar.integer 'user_id'
+    end
+
+    create_table 'categories', :force => true do |category|
+      category.string  'name'
+      category.integer 'parent_id'
+    end
+
+    create_table 'comments', :force => true do |comment|
+      comment.boolean 'flagged_as_spam', :default => false
+    end
+
+    create_table 'episodes', :force => true do |episode|
+      episode.integer 'show_id'
+      episode.string  'name'
+      episode.date    'original_air_date'
+    end
+
+    create_table 'external_users', :force => true do |external_user|
+    end
+
+    create_table 'networks', :force => true do |network|
+      network.string 'name'
+    end
+    
+    create_table 'shows', :force => true do |show|
+      show.integer 'network_id', 'subscription_price'
+      show.string  'name'
+    end
+    
+    create_table 'subscriptions', :force => true do |subscription|
+      subscription.integer 'subscribable_id', 'user_id'
+      subscription.string  'subscribable_type'
+    end
+
+    create_table "tags", :force => true do |t|
+      t.string  "tag"
+    end
+
+    create_table 'topics', :force => true do |t|
+      t.string  'name'
+      t.integer 'parent_id'
+      t.boolean 'root', :default => false
+    end
+
+    create_table 'users', :force => true do |user|
+      user.integer 'favorite_blog_post_id', 'external_user_id'
+      user.string  'email', 'gender', 'homepage', 'login', 'password'
+    end
+
+    create_table 'user2s', :force => true do |user2|
+      user2.string  'login'
+    end
+    
+    create_table 'user_with_passwords', :force => true do |user|
+    end
+    
+    create_table 'videos', :force => true do |video|
+      video.integer 'episode_id', 'show_id', 'network_id', 'view_count'
+    end
+
+    create_table 'video_favorites', :force => true do |video_favorite|
+      video_favorite.integer 'user_id', 'video_id'
+    end
+  
+    create_table 'video_takedown_events', :force => true do |vte|
+      vte.integer 'video_id'
+    end
+  end
+end