modelfactory 0.7.0

data/History.txt

@@ -0,0 +1,7 @@
+== 0.7.0 2008-11-11
+
+* Documentation and rubygem
+
+== 0.0.1 2008-01-25
+
+* Initial release

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Zack Hobson and Justin Balthrop, Geni.com
+
+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.txt

@@ -0,0 +1,15 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/fixture_converter.rb
+lib/model_factory.rb
+lib/model_factory/version.rb
+script/destroy
+script/fixtures2factories
+script/generate
+script/txt2html
+setup.rb
+test/model_factory_test.rb
+test/test_helper.rb

data/README.txt

@@ -0,0 +1,91 @@
+= ModelFactory
+
+ModelFactory is a module designed to replace the use of fixtures for testing
+Rails applications.
+
+The idea is that instead of keeping your test data in a nearly opaque fixture
+file, you generate data in the test itself using a custom factory API designed
+for your test environment.
+
+By creating a new module just for your test factory API you make it easier
+to spot factory calls in your tests and keep your factory code out of your
+test code. ModelFactory adds some useful facilities for generating optional
+defaults for commonly instantiated types. It also fakes up id generation in
+the ActiveRecord models created with new, to assist in unit testing without
+the database.
+
+=== A Note About Defaults
+
+When writing tests that use factory-generated objects, it's important never
+to depend on default values in your test assertions. If you depend on defaults
+in your tests they become more fragile and the intention is harder to discern.
+
+If you find yourself repeating the same initialization to avoid using defaults,
+consider whether it would be appropriate to add a custom toplevel method to
+your factory module that includes this initialization.
+
+=== A Note About ID Generation
+
+Since basic ID generation is done when you instantiate objects using
+Factory.new_<type> it is recommended not to mix such objects with those
+created using Factory.create_<type>. Use the former in unit tests and
+use the latter in functional tests.
+
+== Using ModelFactory
+
+Put something like this in your test helper:
+
+ require 'model_factory'
+
+ module Factory
+   extend ModelFactory
+
+   # a default block accepts a class and a hash of default values
+   default Color, {
+     :name => 'chartreuse'
+   }
+
+   default User, {
+     :first_name => 'Harry',
+     :last_name => 'Manchester',
+     :favorite_color => default_color
+   }
+
+   # Add class methods to create whatever kind of objects you need for your tests
+   def self.new_user_with_colorblindness
+     new_user { :favorite_color => nil }
+   end
+
+ end
+
+Then in your tests you use Factory methods to instantiate your test objects:
+
+ # For most functional tests you can use create.
+ def test_something
+   user = Factory.create_user
+   user.friends << Factory.create_user(:first_name => 'Frank')
+   assert user.likes_frank?
+ end
+
+ # For unit tests you use new.
+ def test_something_else
+   user = Factory.new_user(:favorite_color => Factory.new_color(:name => 'blue'))
+   assert user.likes_blue?
+ end
+
+ # Assertions should not depend on default data, but it can be useful to create
+ # factory methods that build objects with specific traits.
+ def test_yet_something_else
+   user = Factory.new_user_with_colorblindness
+   assert !user.likes_blue?
+ end
+
+== Installing ModelFactory
+
+ sudo gem install modelfactory
+
+== License
+
+Copyright (c) 2008 Justin Balthrop and Zack Hobson
+Published under The MIT License, see License.txt
+

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'hoe'
+$:.unshift(File.dirname(__FILE__) + "/lib")
+require 'model_factory/version'
+
+Hoe.new('ModelFactory', ModelFactory::VERSION::STRING) do |p|
+  p.name = "modelfactory"
+  p.author = ['Justin Balthrop', 'Zack Hobson']
+  p.description = "A replacement for fixtures."
+  p.email = "justin@geni.com"
+  p.summary = "A replacement for fixtures."
+  p.url = "http://modelfactory.rubyforge.org/"
+  p.rubyforge_name = 'modelfactory'
+  p.remote_rdoc_dir = '' # Release to root
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.test_globs = ["test/**/*_test.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']
+end
+
+

data/lib/fixture_converter.rb

@@ -0,0 +1,97 @@
+class FixtureConverter
+  def initialize(opts = {})
+    @body   = []
+    @header = []
+    @indent_depth = opts[:indent_depth] || 0
+    @output_style = opts[:output_style]
+  end
+  
+  def powder?
+    @output_style == :clay
+  end
+  
+  def convert_fixture(path)
+    fixture = YAML.load_file(path)
+    return if not fixture
+
+    plural_model_name = path.basename.to_s.split('.').first
+    model_name        = plural_model_name.singularize
+    header do
+      "#{plural_model_name} = {}"
+    end
+
+    body 'before(:all) do' if powder?
+    indent(powder?) do
+      body "# Setup #{plural_model_name}"
+      body "# Generated from fixture in #{path.dirname.basename}/#{path.basename}"
+      body '#'
+      body ''
+      fixture.each do |name, record|
+        max_length = record.keys.collect {|key| key.length}.max
+      
+        body "#{plural_model_name}[:#{name}] = Factory.create_#{model_name}("
+        indent do
+          body do
+            record.collect do |key,value|
+              value = "\"#{value}\"" if value.kind_of?(String)
+              key   = key.ljust(max_length)
+              ":#{key} => #{value}"
+            end
+          end
+        end
+        body ')'
+      end
+    end
+    body 'end' if powder?
+    body ''
+  end
+
+  def convert_scenario(path)
+    path.each_entry do |file|
+      next if file.extname != '.yml'
+      next if file.basename.to_s =~ /relationships/
+      convert_fixture( path + file )
+    end
+  end
+
+  def out
+    puts @header.join("\n")
+    puts "\n"
+    puts @body.join("\n")
+  end
+
+private
+  INDENT = '  '
+
+  def indent(enabled = true)
+    @indent_depth += 1 if enabled
+    yield
+    @indent_depth -= 1 if enabled
+  end
+
+  def body(*lines)
+    lines = yield if block_given?
+    lines = [lines].flatten
+    
+    lines.each do |line|
+      @body << indent_line(line, @indent_depth)
+    end
+  end
+
+  def header(*lines)
+    lines = yield if block_given?
+    lines = [lines].flatten
+    
+    lines.each do |line|
+      @header << line
+    end
+  end
+  
+  def indent_line(line, indent_depth)
+    ws = ''
+    indent_depth.times do
+      ws += INDENT
+    end
+    ws + line
+  end
+end

data/lib/model_factory.rb

@@ -0,0 +1,111 @@
+require 'active_record'
+
+module ModelFactory
+  def next_local_id # :nodoc:
+    @max_id ||= 0
+    return @max_id += 1
+  end
+
+  #
+  # When specifying defaults, you should only provide only enough data that
+  # the created instance is valid. If you want to include another factory
+  # object as a dependency use the special method default_* instead of
+  # create_* or new_*.
+  #
+  def default(class_type, defaults={})
+    class_name = class_type.name.demodulize.underscore
+  
+    (class << self; self; end).module_eval do
+      define_method "create_#{class_name}" do |*args|
+        attributes = args.first || {}
+        create_instance(class_type, attributes, defaults)
+      end
+    
+      define_method "new_#{class_name}" do |*args|
+        attributes = args.first || {}
+        new_instance(class_type, attributes, defaults)
+      end
+
+      define_method "default_#{class_name}" do |*args|
+        attributes = args.first || {}
+        default_closure(class_type, attributes, defaults)
+      end
+    end
+  end
+    
+  def create_instance(class_type, attributes, defaults = {}) # :nodoc:
+    attributes = instantiate_defaults(:create, defaults.merge(attributes))
+    instance = class_type.create!(attributes)
+    if update_protected_attributes(instance, attributes)
+      instance.save
+    end
+    instance
+  end
+  
+  def new_instance(class_type, attributes, defaults = {}) # :nodoc:
+    attributes = instantiate_defaults(:new, defaults.merge(attributes))
+    instance = class_type.new(attributes)
+    instance.id = next_local_id
+    update_protected_attributes(instance, attributes)
+    instance
+  end
+
+  def default_closure(class_type, attributes, defaults = {}) # :nodoc:
+    lambda do |create_or_new|
+      case create_or_new
+      when :new    : new_instance(class_type, attributes, defaults)
+      when :create : create_instance(class_type, attributes, defaults)
+      end
+    end
+  end
+  
+  def instantiate_defaults(create_or_new, attributes) # :nodoc:
+    attributes.each do |key, value|
+      if value.is_a?(Proc)
+        attributes[key] = value.arity == 0 ? value.call : value.call(create_or_new)
+      end
+    end
+    attributes
+  end
+
+  def update_protected_attributes(instance, attributes) # :nodoc:
+    modified = false
+    protected_attrs  = instance.class.protected_attributes
+    protected_attrs  = protected_attrs.to_set if protected_attrs
+    accessible_attrs = instance.class.accessible_attributes
+    accessible_attrs = accessible_attrs.to_set if accessible_attrs
+
+    if protected_attrs or accessible_attrs
+      attributes.each do |key, value|
+        # Support symbols and strings.
+        [key, key.to_s].each do |attr|
+          next if protected_attrs  and not protected_attrs.include?(attr)
+          next if accessible_attrs and accessible_attrs.include?(attr)
+        end
+        modified = true
+        instance.send("#{key}=", value)
+      end
+    end
+    return modified
+  end
+
+  # Any class methods of the form "new_some_type(attrs)" or "create_some_type(attrs)" will be converted to
+  # "SomeType.new(attrs)" and "SomeType.create!(attrs)" respectively.
+  # These basically function as though you'd used the 'default' directive with empty defaults.
+  def method_missing(missing_method, attributes = {})
+    if missing_method.to_s.match(/^(new|create|default)_([a-z][\w_]+)$/)
+      method, class_name = $1, $2
+      class_type = class_name.camelize.constantize
+      case method
+      when 'create'
+        create_instance(class_type, attributes)
+      when 'new'
+        new_instance(class_type, attributes)
+      when 'default'
+        default_closure(class_type, attributes)
+      end
+    else
+      raise NoMethodError, "no such method '#{missing_method}'"
+    end
+  end
+end

data/lib/model_factory/version.rb

@@ -0,0 +1,9 @@
+module ModelFactory #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 7
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/fixtures2factories

@@ -0,0 +1,18 @@
+#!/usr/bin/ruby
+require 'rubygems'
+require 'active_support'
+require 'pp'
+require 'pathname'
+require 'yaml'
+require File.dirname(__FILE__) + '/../lib/fixture_converter'
+
+path = Pathname.new(ARGV[0])
+
+fc = FixtureConverter.new
+if path.file?
+  fc.convert_fixture(path)
+else
+  fc.convert_scenario(path)
+end
+fc.out
+

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+begin
+  require 'newgem'
+rescue LoadError
+  puts "\n\nGenerating the website requires the newgem RubyGem"
+  puts "Install: gem install newgem\n\n"
+  exit(1)
+end
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + '/../lib/model_factory/version.rb'
+
+version  = ModelFactory::VERSION::STRING
+download = 'http://rubyforge.org/projects/model_factory'
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.rhtml')
+  
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text = fsrc.read
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)