active_factory 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest

@@ -0,0 +1,17 @@
+MIT-LICENSE
+README.rdoc
+Rakefile
+init.rb
+lib/active_factory.rb
+lib/generators/active_factory/install/USAGE
+lib/generators/active_factory/install/install_generator.rb
+lib/generators/active_factory/install/templates/active_factory.rb
+lib/generators/active_factory/install/templates/define_factories.rb
+lib/hash_struct.rb
+spec/active_factory_define_spec.rb
+spec/active_factory_spec.rb
+spec/active_record_environment_spec.rb
+spec/define_lib_factories.rb
+spec/spec_helper.rb
+spec/support/active_record_environment.rb
+Manifest

data/README.rdoc

@@ -0,0 +1,113 @@
+== ActiveFactory
+
+<em>A fixture replacement library. With it your specs will become more declarative, uniform and terse.</em>
+
+<b>Feedback will be highly appreciated</b>
+
+* {Google group}[http://groups.google.com/group/active_factory]
+* {Factory Definition Reference}[https://github.com/tarasevich/active_factory/wiki/Factory-Definition-Reference]
+* {Models Clause Reference}[https://github.com/tarasevich/active_factory/wiki/Models-Clause-Reference]
+
+== Introduction
+
+ActiveFactory allows you declaratively define
+which objects you want to have in a database for your spec.
+You can also define associations between the objects and
+redefine default values.
+Additionally ActiveFactory automatically defines accessor methods for the objects.
+The scope of the methods is limited to current spec. So they will not affect you other specs.
+
+  it "Task.incomplete returns only incomplete tasks" do
+    models { project - tasks({:complete => 0}, {:complete => 1}) }
+
+    project.tasks.incomplete.should == [tasks[0]]
+  end
+
+  it "project displays incomplete tasks" do
+    models { my - project - task(:complete => 0) }
+
+    visit project_path(project)
+
+    page.should have_content task.title
+  end
+
+These specs require the following configuration:
+
+  class ActiveFactory::Define
+
+    factory :my, :class => User do
+      username "my_name"
+      password "my_password"
+
+      before_save do
+        model.save!
+        context.emulate_sign_in model      
+      end
+    end
+
+    factory :project do
+      title { "Project #{index} title" }
+      due { Time.now }
+    end
+
+    factory :task do
+      title { "Task #{index} title" }
+    end
+  end
+
+In the configuration you specify default attribute values for an object,
+and in a specific test you may reassign the values for the needs of the test.
+Optional block after_build specifies actions that should be done
+after object was initialized but before saving it.
+If you want to create by the same factory several objects with different values,
+you may use blocks.
+Method index in those blocks returns index of the object being created.
+
+== Installation
+
+ActiveFactory requires Rails 3 and RSpec 2.
+
+   rails plugin install git@github.com:tarasevich/active_factory.git
+   rails g active_factory:install
+
+Now you are ready to add you factories spec/define_factories.rb
+and use models {} block in your specs.
+
+<em>Copyright (c) 2010-2011 Alexey Tarasevich, released under the MIT license</em>
+
+== Some Examples
+
+Consider we have factory declarations from introduction secion.
+
+  describe ProjectController do
+
+    it "creates a new project" do
+      models { my ; project_ }
+
+      post :create, :project => project_
+
+      Project.all.map(&:title).should == [project_[:title]]
+    end
+  ...
+
+In previous example factory +my+ in +models+ block causes to emulate login.
++project_+ declares corresponding method inside the spec.
+Syntax with uderscore indicates that it's should be just hash
+with values taken from the factory declaration.
+In our case it will be <code>{:title => "Project 0 title"}</code>
+
+    it "modifies a project's title" do
+      models { my - project }
+
+      put :update, :id => project.id, :project => project_(:title => "New Title")
+
+      project.reload.title.should == "New Title"
+    end
+
+In this example we again use +my+ to create a user and log in with it.
+Additionally we create +Project+ instance using +project+ factory
+and define method +project+ locally for the spec.
+Finally we use minus sign to create association between user +my+ and +project+.
+Active factory iterates through associations of +User+ model and chooses the one that
+has +Project+ on the other side.
+<code>project_(h)</code> is just syntax sugar for <code>project_.merge(h)</code>

data/Rakefile

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'rake'
+require 'rake/rdoctask'
+require 'rspec/core/rake_task'
+require 'echoe'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end
+
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+Echoe.new('active_factory', '0.1.0') do |p|
+  p.description = "Fixtures replacement with sweet syntax"
+  p.url = "http://github.com/tarasevich/active_factory"
+  p.author = "Alexey Tarasevich"
+  p.ignore_pattern = ["tmp/*", "script/*"]
+  p.development_dependencies = []
+end
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }
+
+
+desc 'Generate documentation for the active_factory plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActiveFactory'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/active_factory.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{active_factory}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alexey Tarasevich"]
+  s.date = %q{2011-04-21}
+  s.description = %q{Fixtures replacement with sweet syntax}
+  s.email = %q{}
+  s.extra_rdoc_files = ["README.rdoc", "lib/active_factory.rb", "lib/generators/active_factory/install/USAGE", "lib/generators/active_factory/install/install_generator.rb", "lib/generators/active_factory/install/templates/active_factory.rb", "lib/generators/active_factory/install/templates/define_factories.rb", "lib/hash_struct.rb"]
+  s.files = ["MIT-LICENSE", "README.rdoc", "Rakefile", "init.rb", "lib/active_factory.rb", "lib/generators/active_factory/install/USAGE", "lib/generators/active_factory/install/install_generator.rb", "lib/generators/active_factory/install/templates/active_factory.rb", "lib/generators/active_factory/install/templates/define_factories.rb", "lib/hash_struct.rb", "spec/active_factory_define_spec.rb", "spec/active_factory_spec.rb", "spec/active_record_environment_spec.rb", "spec/define_lib_factories.rb", "spec/spec_helper.rb", "spec/support/active_record_environment.rb", "Manifest", "active_factory.gemspec"]
+  s.homepage = %q{http://github.com/tarasevich/active_factory}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Active_factory", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{active_factory}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Fixtures replacement with sweet syntax}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'active_factory'  if Rails.env == 'test'

data/lib/active_factory.rb

@@ -0,0 +1,480 @@
+require 'hash_struct'
+
+module ActiveFactory
+  # should be included in specs
+  module API
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :_active_factory_context_extension
+
+      after do
+        _active_factory_context_extension.try :undo
+        self._active_factory_context_extension = nil
+      end
+    end
+
+    module ClassMethods
+      def factory_attributes model_name, index = 0
+        Define.
+            factories_hash[model_name].
+            attributes_for(index)
+      end
+    end
+
+    # methods available in specs
+    module InstanceMethods
+      def models &define_graph
+        not _active_factory_context_extension or raise "cannot use models twice in an example"
+
+        context = self
+        factories_hash = Define.factories_hash
+        containers_hash = Hash.new { |this, name|
+          factory = factories_hash[name]
+          this[name] = Container.new(name, factory, context)
+        }
+        linking_context = LinkingContext.new factories_hash.keys, containers_hash, context
+        self._active_factory_context_extension = ContextExtension.new
+
+        linking_context.instance_eval &define_graph
+        containers_hash.values.each &:before_save
+        containers_hash.values.each &:save
+        _active_factory_context_extension.extend_test_context containers_hash, context
+        nil
+      end
+    end
+  end
+
+  class FactoryDSL
+    def initialize
+      @attribute_expressions = {}
+    end
+
+    def prefer_associations *assoc_symbols
+      @prefer_associations = assoc_symbols
+    end
+
+    def after_build &callback
+      @after_build = callback
+    end
+
+    def before_save &callback
+      @before_save = callback
+    end
+
+    def method_missing method, *args, &expression
+      if args.many? or args.any? and block_given?
+        raise "should be either block or value: #{method} #{args.inspect[1..-2]}"
+      end
+      @attribute_expressions[method.to_sym] = expression || proc { args[0] }
+    end
+  end
+
+  # the class that should be "extended" to define models
+  class Define
+    @@factories = {}
+
+    def self.factory name, options = {}, &block
+      model_class = options[:class]
+      if parent_sym = options[:parent]
+        parent = @@factories[parent_sym] or raise "undefined parent factory #{parent_sym}"
+      end
+      
+      @@factories[name] = FactoryDSL.new.instance_eval {
+        instance_eval(&block)
+        Factory.new name, parent, model_class,
+          @prefer_associations, @attribute_expressions, @after_build, @before_save
+      }
+    end
+
+    def self.factories_hash
+      @@factories
+    end
+  end
+
+  # defines methods that can be used in a model definition
+  # model - the model under construction
+  # index - index of the model in the factory
+  # context - spec context where the models {} block was evaluated
+  class CreationContext < Struct.new :index, :context, :model
+    alias i index
+  end
+
+  # creates instances of the given model class
+  class Factory < Struct.new :name, :parent, :model_class,
+                             :prefer_associations, :attribute_expressions, :after_build, :before_save
+    def initialize name, parent, *overridable
+      @overridable = parent ? parent.merge_overridable(overridable) : overridable
+      super(name, parent, *@overridable)
+      self.attribute_expressions = 
+        parent.attribute_expressions.merge(self.attribute_expressions) if parent
+      
+      name.is_a? Symbol or raise "factory name #{name.inspect} must be symbol"
+      self.model_class ||= (@overridable[0] = Kernel.const_get(name.to_s.capitalize))
+    end
+    
+    def merge_overridable overridable
+      overridable.zip(@overridable).
+      map { |his, my| his or my }
+    end
+    
+    def attributes_for index
+      context = CreationContext.new(index)
+      attrs = attribute_expressions.map { |a, e| [a, context.instance_eval(&e)] }
+      Hash[attrs]
+    end
+
+    def apply_after_build index, context, model
+      if after_build
+        CreationContext.new(index, context, model).
+            instance_eval(&after_build)
+      end
+    end
+
+    def apply_before_save index, context, model
+      if before_save
+        CreationContext.new(index, context, model).
+            instance_eval(&before_save)
+      end
+    end
+  end
+
+  class ContainerEntry
+    attr_reader :model, :attrs
+
+    def initialize index, factory, context
+      @index = index
+      @factory = factory
+      @attrs = HashStruct[factory.attributes_for(index)]
+      @context = context
+    end
+
+    def merge hash
+      @attrs = @attrs.merge hash
+    end
+
+    def build
+      unless @model
+        @model = @factory.model_class.new
+        @attrs.each_pair { |k,v| @model.send "#{k}=", v }
+
+        @factory.apply_after_build @index, @context, @model
+      end
+    end
+
+    def before_save
+      if @model and not @saved
+        @factory.apply_before_save @index, @context, @model
+      end
+    end
+
+    def save
+      if @model and not @saved
+        @model.save!
+        @saved = true
+      end
+    end
+  end
+
+  # keeps collection of created instances of the given model class
+  class Container
+    attr_accessor :entries
+    attr_reader :name, :factory
+
+    def initialize name, factory, context
+      @name = name
+      @factory = factory
+      @context = context
+      @entries = [].freeze
+    end
+
+    def create count
+      dup_with add_entries count
+    end
+
+    def singleton
+      if @entries.none?
+        add_entries 1
+      elsif @entries.many?
+        raise "Multiple instances were declared for model :#{@name}."+
+              "Use <#{@name.to_s.pluralize}> to access them"
+      end
+      self
+    end
+
+    def zip_merge *hashes
+      @entries.size == hashes.size or raise
+
+      @entries.zip(hashes) { |entry, hash|
+        entry.merge hash
+      }
+      self
+    end
+
+    def build
+      @entries.each &:build
+      self
+    end
+
+    def make_linker
+      Linker.new self
+    end
+
+    def before_save
+      @entries.each &:before_save
+    end
+
+    def save
+      @entries.each &:save
+    end
+
+    def attrs
+      @entries.map &:attrs
+    end
+
+    def objects
+      @entries.map &:model
+    end
+
+    private
+
+    def dup_with entries
+      that = clone
+      that.entries = entries
+      that
+    end
+
+    def add_entries count
+      size = @entries.size
+      added = (size...size+count).
+          map { |i| ContainerEntry.new i, factory, @context }
+      @entries = (@entries + added).freeze
+      added
+    end
+  end
+
+  # provides syntax to create associations between models
+  class Linker
+    def initialize container, use_association = nil
+      @container = container
+      @use_association = use_association
+
+      @entries = container.entries
+      @model_class = container.factory.model_class
+      @prefer_associations = container.factory.prefer_associations
+    end
+
+    attr_accessor :entries, :model_class
+
+    def - that
+      case that
+        when Linker
+          associate that
+          that
+        when Symbol
+          Linker.new @container, that
+        else
+          raise "cannot associate with #{that.inspect}"
+      end
+    end
+
+    private
+
+    def associate linker
+      ar = get_association linker.model_class
+
+      case ar.macro
+        when :has_many, :has_and_belongs_to_many
+          assoc_entries = proc { |e, e2|
+            e.model.send(ar.name) << e2.model
+          }
+
+          if entries.one? or linker.entries.one?
+            entries.each { |e|
+              linker.entries.each { |e2|
+                assoc_entries[e, e2]
+              }
+            }
+
+          elsif entries.size == linker.entries.size
+            entries.zip(linker.entries) { |e, e2|
+              assoc_entries[e, e2]
+            }
+
+          else
+            raise "when linking models, they should be one of this: 1-n, n-1, n-n (e.i. equal number)"
+          end
+
+        when :belongs_to, :has_one
+          assoc_entries = proc { |e, e2|
+            e.model.send :"#{ar.name}=", e2.model
+          }
+
+          if linker.entries.one?
+            entries.each { |e|
+              assoc_entries[e, linker.entries.first]
+            }
+
+          elsif entries.size == linker.entries.size
+            entries.zip(linker.entries) { |e, e2|
+              assoc_entries[e, e2]
+            }
+
+          else
+            raise "exactly one instance of an object should be assigned to belongs_to association: #{@container.name} - #{linker.instance_variable_get(:@container).try :name}"
+          end
+      end
+    end
+
+    def get_association with_class
+      if @use_association
+        @model_class.reflect_on_association(@use_association) or
+          raise "No association #{@use_association.inspect} found for #{@model_class}"
+      else
+        find_association with_class
+      end
+    end
+
+    def find_association with_class
+      assocs = @model_class.reflect_on_all_associations.find_all { |assoc|
+        assoc.class_name == with_class.name
+      }
+
+      if assocs.none?
+        raise "Trying to link, but no association found from #{@model_class} to #{with_class}"
+
+      elsif assocs.one?
+        assocs.first
+
+      elsif assocs.many?
+        resolved = assocs.select { |assoc| @prefer_associations.member? assoc.name }
+        resolved.one? or
+            raise "Ambiguous associations: #{assocs.map(&:name).inspect} of #{@model_class} to #{with_class}. prefer_associations=#{@prefer_associations.inspect}"
+
+        resolved.first
+      end
+    end
+
+  end
+
+  # provides methods that refer models in models {} block
+  class LinkingContext
+    def initialize model_names, containers_hash, context
+      @context = context
+      h = containers_hash
+
+      obj_class_eval do
+        model_names.each { |name|
+
+          define_method name do |*args|
+            not args.many? or raise "0 or 1 arguments expected, got: #{args.inspect}"
+
+            if args.none?
+              h[name].singleton
+            else
+              h[name].singleton.zip_merge(args[0])
+
+            end.build.make_linker
+          end
+
+          define_method :"#{name.to_s.pluralize}" do |*args|
+
+            if args.none?
+              h[name]
+
+            elsif args[0].is_a? Fixnum and args.one?
+              h[name].create(args[0])
+
+            elsif args.all? { |arg| arg.is_a? Hash }
+              h[name].create(args.size).zip_merge(*args)
+
+            else
+              raise "expected no args, or single integer, or several hashes, got: #{args.inspect}"
+
+            end.build.make_linker
+          end
+
+          define_method :"#{name}_" do
+            h[name].singleton.make_linker
+          end
+
+          define_method :"#{name.to_s.pluralize}_" do |count|
+            h[name].create(count).make_linker
+          end
+        }
+      end
+    end
+
+    private
+
+    def obj_class_eval &block
+      class << self
+        self
+      end.class_eval &block
+    end
+
+    def method_missing *args, &block
+      if block
+        @context.send *args, &block
+      else
+        @context.send *args
+      end
+    end
+  end
+
+  # introduces models' names in a spec's context
+  class ContextExtension
+    def undo
+      @undo_define_methods[] if @undo_define_methods
+      @undo_define_methods = nil
+    end
+
+    def extend_test_context containers_hash, context
+      mrg = proc {|args, hash|
+        if args.none?
+          hash
+        elsif args.one? and args[0].is_a? Hash
+          hash.merge args[0]
+        else
+          raise "Only has is valid argument, but *args=#{args.inspect}"
+        end
+      }
+
+      method_defs =
+          containers_hash.map { |name, container| [
+              name, proc { container.singleton.objects[0] },
+              :"#{name}_", proc { |*args| mrg[args, container.singleton.attrs[0]] },
+              :"#{name.to_s.pluralize}", proc { container.objects },
+              :"#{name.to_s.pluralize}_", proc { container.attrs }
+          ] }.
+              flatten.each_slice(2)
+
+      @undo_define_methods =
+          define_methods_with_undo context, method_defs
+    end
+
+    private
+
+    def define_methods_with_undo model, method_defs
+      old_methods = model.methods.map &:to_sym
+
+      overridden_methods, new_methods =
+          method_defs.
+              map(&:first).
+              partition { |name| old_methods.include? name.to_sym }
+
+      overridden_methods.map! { |name| [name, model.method(name)] }
+
+      define_method, undef_method = class << model
+        [method(:define_method), method(:undef_method)]
+      end
+
+      method_defs.each{ |n,b| define_method[n,b] }
+
+      lambda {
+        overridden_methods.each{ |n,b| define_method[n,b] }
+        new_methods.each &undef_method
+      }
+    end
+  end
+end