kathy_lee 0.1.0 → 0.2.0

data/README

@@ -1,150 +1 @@
-=Kathy Lee
-
-An easy to use factory framework for generating test data for ActiveRecord models.
-
-==Setup Examples
-
-  KathyLee::User.define do
-    username(fake(:user_name))
-    email(fake(:email))
-    home_page_url(fake(:url))
-    fullname(fake(:full_name))
-    login_count(0)
-
-    has_many :posts, :size => 2
-    has_many :comments, :size => 1
-  end
-
-  KathyLee::User::Marge.define do
-    fullname('Marge Simpson')
-    login_count(1000)
-  end
-
-  KathyLee::User::Marge::Other.define do
-    home_page_url('http://www.simpsons.com')
-
-    has_many :posts, :size => 5
-    has_many :comments, :size => 1
-  end
-
-  KathyLee::Post.define do
-    title(fake(:title))
-    body(fake(:body))
-
-    belongs_to :user
-    has_many :comments, :size => 1
-  end
-
-  KathyLee::Comment.define do
-    body(fake(:body))
-
-    belongs_to :user
-    belongs_to :post
-  end
-  
-  KathyLee::Movie.define(:title => 'Rocky II', :director => 'Sly Stallone')
-
-
-  # Build a new unsaved model:
-  user = KathyLee::User.new
-  user.username.should == 'bill.smith'
-  user.email.should == 'bill.smith@example.org'
-  user.home_page_url.should == 'http://www.example.com'
-  user.fullname.should == 'Bill Smith'
-  user.login_count.should == 0
-  user.new_record?.should be_true
-  
-  # Build a new unsaved model with a few overrides:
-  user = KathyLee::User.new(:username => 'mark.bates', :login_count => 5)
-  user.username.should == 'mark.bates'
-  user.email.should == 'bill.smith@example.org'
-  user.home_page_url.should == 'http://www.example.com'
-  user.fullname.should == 'Bill Smith'
-  user.login_count.should == 5
-  user.new_record?.should be_true
-  
-  # Build and save a new model:
-  user = KathyLee::User.create
-  user.username.should == 'bill.smith'
-  user.email.should == 'bill.smith@example.org'
-  user.home_page_url.should == 'http://www.example.com'
-  user.fullname.should == 'Bill Smith'
-  user.login_count.should == 0
-  user.new_record?.should be_false
-  
-  # Build and save a new model with a few overrides:
-  user = KathyLee::User.create(:username => 'mark.bates')
-  user.username.should == 'mark.bates'
-  user.email.should == 'bill.smith@example.org'
-  user.home_page_url.should == 'http://www.example.com'
-  user.fullname.should == 'Bill Smith'
-  user.login_count.should == 0
-  user.new_record?.should be_false
-  
-  # Build many unsaved models (can be used with/without block):
-  users = KathyLee::User.sweatshop(10) do |user, index|
-    user.login_count = index
-  end
-  users.size.should == 10
-  users.each_with_index do |user, index|
-    user.login_count.should == index
-    user.new_record?.should be_true
-  end
-  
-  # Build and save many models (can be used with/without block):
-  users = KathyLee::User.sweatshop!(10) do |user, index|
-    user.login_count = index
-  end
-  users.size.should == 10
-  users.each_with_index do |user, index|
-    user.login_count.should == index
-    user.new_record?.should be_false
-  end
-  
-  # Build belongs_to associations (change KathyLee::Post.new to KathyLee::Post.create to save the whole thing):
-  post = KathyLee::Post.new
-  post.title.should_not be_nil
-  post.user.should_not be_nil
-  post.user.should be_kind_of(User)
-  post.user.email.should == 'bill.smith@example.org'
-  
-  # Build has_many associations (change KathyLee::User.new to KathyLee::User.create to save the whole thing):
-  user = KathyLee::User.new
-  user.should_not be_nil
-  user.posts.should_not be_nil
-  user.posts.size.should == 2
-  user.posts.each do |post|
-    post.should be_kind_of(Post)
-    post.title.should_not be_nil
-  end
-  user.comments.should_not be_nil
-  user.comments.size.should == 1
-  user.comments.each do |comment|
-    comment.should be_kind_of(Comment)
-  end
-  
-  # Build a variant of a model using subclasses:
-  user = KathyLee::User::Marge.new
-  user.username.should == 'bill.smith'
-  user.email.should == 'bill.smith@example.org'
-  user.home_page_url.should == 'http://www.example.com'
-  user.fullname.should == 'Marge Simpson'
-  user.login_count.should == 1000
-  user.new_record?.should be_true
-  user.posts.size.should == 2
-  
-  # Subclass your subclass for further customization:
-  user = KathyLee::User::Marge::Other.new
-  user.username.should == 'bill.smith'
-  user.email.should == 'bill.smith@example.org'
-  user.home_page_url.should == 'http://www.simpsons.com'
-  user.fullname.should == 'Marge Simpson'
-  user.login_count.should == 1000
-  user.new_record?.should be_true
-  user.posts.size.should == 5
-
-==Contact
-
-Please mail bugs, suggestions and patches to "development@metabates.com":mailto:development@metabates.com
-
-On the web at: "http://www.metabates.com":http://www.metabates.
+=KathyLee - An easy to use factory framework for generating test data for objects.

data/lib/generators/kathy_lee/model/model_generator.rb

@@ -0,0 +1,14 @@
+require 'generators/kathy_lee'
+
+class KathyLee
+  module Generators
+    class ModelGenerator < Base
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+      class_option :dir, :type => :string, :default => "spec/factories", :desc => "The directory where the factories should go"
+      
+      def create_fixture_file
+        template 'fixtures.rb', File.join(options[:dir], "#{singular_name}_factories.rb")
+      end
+    end
+  end
+end

data/lib/generators/kathy_lee/model/templates/fixtures.rb

@@ -0,0 +1,11 @@
+# Define attributes for <%= class_name %>:
+KathyLee.attributes(:<%= singular_name %>) do
+<% for attribute in attributes -%>
+  <%= attribute.name %> <%= attribute.default.inspect %>
+<% end -%>
+end
+
+KathyLee.define(:<%= singular_name %>) do
+  <%= singular_name %> = <%= class_name %>.new(options)
+  <%= singular_name %>
+end

data/lib/generators/kathy_lee.rb

@@ -0,0 +1,11 @@
+require 'rails/generators/named_base'
+
+class KathyLee
+  module Generators
+    class Base < Rails::Generators::NamedBase #:nodoc:
+      def self.source_root
+        @_kathy_lee_source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'kathy_lee', 'model', 'templates'))
+      end
+    end
+  end
+end

data/lib/kathy_lee/attributes/binding.rb

@@ -0,0 +1,31 @@
+class KathyLee::Attributes::Binding
+  
+  attr_accessor :results
+  attr_accessor :attributes
+  attr_accessor :code_block
+  
+  def initialize(attributes = {}, &block)
+    self.results = {}
+    self.attributes = attributes
+    self.code_block = block
+  end
+  
+  def process!
+    if self.code_block
+      instance_eval(&self.code_block)
+    end
+    self.results.merge!(self.attributes)
+  end
+  
+  def fake(name)
+    KathyLee::Fakes.execute(name)
+  end
+  
+  def method_missing(sym, args = nil, &block)
+    self.results[sym] = args unless args.nil?
+    if block_given?
+      self.results[sym] = block.call
+    end
+  end
+  
+end

data/lib/kathy_lee/attributes.rb

@@ -0,0 +1,18 @@
+class KathyLee::Attributes
+  
+  attr_accessor :attributes
+  attr_accessor :code_block
+  
+  def initialize(attributes = {}, &block)
+    self.attributes = attributes
+    self.code_block = block
+  end
+  
+  def process(attribs = {})
+    b = KathyLee::Attributes::Binding.new(self.attributes.merge(attribs), &self.code_block)
+    b.process!
+    return b.results
+  end
+  
+  
+end

data/lib/kathy_lee/definition/binding.rb

@@ -0,0 +1,72 @@
+# Used to evaluate a KathyLee::Definition in it's own 'space' (binding)
+class KathyLee::Definition::Binding
+  
+  attr_accessor :factory_name
+  attr_accessor :options
+  attr_accessor :code_block
+  attr_accessor :result
+  attr_accessor :has_ones
+  attr_accessor :has_manys
+  attr_accessor :parent
+  
+  def initialize(factory_name, attributes = {}, &block)
+    self.factory_name = factory_name
+    attrib_name = attributes.delete(:attributes_for) || factory_name.to_sym
+    self.options = (KathyLee.attributes(attrib_name) || {}).merge(attributes)
+    self.code_block = block
+    self.has_ones = {}
+    self.has_manys = {}
+  end
+  
+  def has_one(factory, options = {}, &block)
+    self.has_ones[factory.to_sym] = {:options => options, :code_block => block, 
+                                     :klass => self.options.delete(factory.to_sym)}
+  end
+  
+  def has_many(factory, options = {}, &block)
+    options = {:size => 2}.merge(options)
+    self.has_manys[factory.to_sym] = KathyLee::Definition::HasMany.new(factory.to_sym, {:options => options, :code_block => block, :klass => self.options.delete(factory.to_sym)})
+  end
+  
+  def process!
+    self.result = instance_eval(&self.code_block)
+    handle_has_ones
+    handle_has_manys
+  end
+  
+  protected
+  def handle_has_ones
+    self.has_ones.each do |factory, h|
+      if h[:klass]
+        self.result.send("#{factory}=", h[:klass])
+      else
+        if h[:code_block]
+          b = KathyLee::Definition::Binding.new(factory, h[:options], &h[:code_block])
+          # b.send(:eval, %{
+          #   def #{self.factory_name}=(x)
+          #     @__#{self.factory_name} = x
+          #   end
+          #   def #{self.factory_name}
+          #     @__#{self.factory_name}
+          #   end
+          # })
+          # b.send("#{self.factory_name}=", self.result)
+          b.parent = self.result
+          b.process!
+          self.result.send("#{factory}=", b.result)
+        else
+          self.result.send("#{factory}=", KathyLee.build(factory, h[:options]))
+        end
+      end
+    end
+  end
+  
+  def handle_has_manys
+    self.has_manys.each do |factory, h|
+      h.build.each do |obj|
+        self.result.send("#{factory}") << obj
+      end
+    end
+  end
+  
+end

data/lib/kathy_lee/definition/has_many.rb

@@ -0,0 +1,27 @@
+class KathyLee::Definition::HasMany < KathyLee::Definition::Relationship
+  attr_accessor :size
+  
+  def initialize(factory, options = {})
+    super(factory, options)
+    self.size = (self.options.delete(:size) || 2)
+  end
+  
+  def build
+    results = []
+    self.size.times do
+      if self.klass
+        results << self.klass
+      else
+        if self.code_block
+          b = KathyLee::Definition::Binding.new(self.factory, self.options, self.code_block)
+          b.process!
+          results << b.result
+        else
+          results << KathyLee.build(self.factory, self.options)
+        end
+      end
+    end
+    [results].flatten
+  end
+  
+end

data/lib/kathy_lee/definition/has_one.rb

@@ -0,0 +1,3 @@
+class KathyLee::Definition::HasOne < KathyLee::Definition::Relationship
+  
+end

data/lib/kathy_lee/definition/relationship.rb

@@ -0,0 +1,14 @@
+class KathyLee::Definition::Relationship
+  attr_accessor :options
+  attr_accessor :code_block
+  attr_accessor :klass
+  attr_accessor :factory
+  
+  def initialize(factory, options = {})
+    self.factory = factory
+    self.options = options
+    self.klass = self.options.delete(:klass)
+    self.code_block = self.options.delete(:code_block)
+  end
+  
+end

data/lib/kathy_lee/definition.rb

@@ -0,0 +1,38 @@
+# Houses the definition of a factory.
+# 
+# Examples:
+#   KathyLee.define(:user) do
+#     user = User.new(options)
+#     ... # do some more work
+#     user
+#   end
+# 
+#   KathyLee.define(:user) do
+#     has_one :blog # will call the :blog factory and assign it to the
+#                   # user object when it's returned from the block.
+# 
+#     user = User.new(options)
+#     ... # do some more work
+#     user
+#   end
+class KathyLee::Definition
+  
+  attr_accessor :factory_name
+  attr_accessor :attributes
+  attr_accessor :code_block
+  
+  def initialize(factory_name, attributes = {}, &block)
+    self.attributes = attributes
+    self.factory_name = factory_name
+    self.code_block = block
+  end
+  
+  # Execute the code block in it's own building, with it's own attributes
+  # and return the result.
+  def build(attribs = {})
+    b = KathyLee::Definition::Binding.new(self.factory_name, self.attributes.merge(attribs), &self.code_block)
+    b.process!
+    return b.result
+  end
+  
+end

data/lib/kathy_lee/fakes.rb

@@ -1,25 +1,41 @@
-module KathyLee
+class KathyLee
+  # A registry for procs that can be called to generate random, or fake, data.
   class Fakes
     include Singleton
-    
+  
+    # List of all the fake procs in the system.
     attr_accessor :list
-    
-    def initialize
+  
+    def initialize # :nodoc:
       self.reset!
     end
-    
-    def reset!
+  
+    def reset! # :nodoc:
       self.list = {}
     end
-    
+  
+    # Add a new proc to the system.
+    # 
+    # Example:
+    #   KathyLee::Fakes.add(:birth_date) {(rand(80) + 13).years.ago}
     def add(name, &block)
       self.list[name.to_sym] = block
     end
     
+    # Create an alias from one fake proc to another.
+    # 
+    # Example:
+    #   KathyLee::Fakes.add(:birth_date) {(rand(80) + 13).years.ago}
+    #   KathyLee::Fakes.alias(:birthday, :birth_date)
     def alias(from, to)
       self.list[from.to_sym] = KathyLee::Fakes::Alias.new(to)
     end
-    
+  
+    # Executes the specified fake proc. Raise KathyLee::Errors::NoFakeRegistered
+    # if the fake proc is not registered with the system.
+    # 
+    # Example:
+    #   KathyLee::Fakes.execute(:email) # => 'bob@example.com'
     def execute(name, *args)
       block = self.list[name.to_sym]
       if block.is_a?(KathyLee::Fakes::Alias)
@@ -28,17 +44,17 @@ module KathyLee
       if block
         return block.call(*args)
       end
-      raise KathyLee::Errors::NoFakeRegistered.new(name)
+      raise "No fake has been registered for '#{name}'!"
     end
-    
+  
     class << self
-      def method_missing(sym, *args, &block)
+      def method_missing(sym, *args, &block) # :nodoc:
         KathyLee::Fakes.instance.send(sym, *args, &block)
       end
     end # class << self
-    
+  
     private
-    class Alias
+    class Alias # :nodoc:
       attr_accessor :to
       def initialize(to)
         self.to = to
@@ -48,34 +64,80 @@ module KathyLee
   end # Fakes
 end # KathyLee
 
-%w{first_name last_name name prefix suffix}.each do |m|
-  eval("KathyLee::Fakes.add(:#{m}) {|*args| Faker::Name.#{m}(*args)}")
+%w{zip_code us_state us_state_short city street_name street_address neighborhood}.each do |m|
+  eval("KathyLee::Fakes.add(:#{m}) {|*args| Dummy::Address.#{m}}")
 end
 
-%w{city city_prefix city_suffix secondary_address street_address street_name 
-   street_suffix uk_country uk_county uk_postcode us_state us_state_abbr zip_code}.each do |m|
-  eval("KathyLee::Fakes.add(:#{m}) {|*args| Faker::Address.#{m}(*args)}")
+%w{name catch_phrase bs}.each do |m|
+  eval("KathyLee::Fakes.add(:#{m}) {|*args| Dummy::Company.#{m}}")
 end
 
-%w{bs catch_phrase name suffix}.each do |m|
-  eval("KathyLee::Fakes.add(:#{m}) {|*args| Faker::Company.#{m}(*args)}")
+KathyLee::Fakes.add(:company_name) {|*args| Dummy::Company.name}
+
+%w{lat lng}.each do |m|
+  eval("KathyLee::Fakes.add(:#{m}) {|*args| Dummy::Geolocation.#{m}}")
 end
 
-%w{domain_name domain_suffix domain_word email free_email user_name}.each do |m|
-  eval("KathyLee::Fakes.add(:#{m}) {|*args| Faker::Internet.#{m}(*args)}")
+%w{email username password url}.each do |m|
+  eval("KathyLee::Fakes.add(:#{m}) {|*args| Dummy::Internet.#{m}}")
 end
 
-%w{paragraph paragraphs sentence sentences words}.each do |m|
-  eval("KathyLee::Fakes.add(:#{m}) {|*args| Faker::Lorem.#{m}(*args)}")
+KathyLee::Fakes.alias(:login, :username)
+
+%w{sentence sentences paragraph paragraphs}.each do |m|
+  eval("KathyLee::Fakes.add(:#{m}) {|*args| Dummy::Lorem.#{m}}")
 end
 
-%w{phone_number}.each do |m|
-  eval("KathyLee::Fakes.add(:#{m}) {|*args| Faker::PhoneNumber.#{m}(*args)}")
+KathyLee::Fakes.add(:lorem) do |*args|
+  lorem = []
+  3.times {lorem << Dummy::Lorem.paragraph}
+  lorem.join("\n")
 end
 
-KathyLee::Fakes.add(:url) {|*args| 'http://' + Faker::Internet.domain_name(*args)}
-KathyLee::Fakes.add(:lorem) {|*args| Faker::Lorem.paragraphs(*args).join("\n")}
-KathyLee::Fakes.add(:name) {|*args| Faker::Name.first_name + ' ' + Faker::Name.last_name}
 KathyLee::Fakes.alias(:body, :lorem)
+
+%w{name first_name last_name}.each do |m|
+  eval("KathyLee::Fakes.add(:#{m}) {|*args| Dummy::Name.#{m}}")
+end
+
 KathyLee::Fakes.alias(:full_name, :name)
-KathyLee::Fakes.alias(:title, :sentence)
+
+%w{phone_number phone_number_short}.each do |m|
+  eval("KathyLee::Fakes.add(:#{m}) {|*args| Dummy::PhoneNumber.#{m}}")
+end
+
+# %w{first_name last_name name prefix suffix}.each do |m|
+#   eval("KathyLee::Fakes.add(:#{m}) {|*args| Faker::Name.#{m}(*args)}")
+# end
+# 
+# %w{city city_prefix city_suffix secondary_address street_address street_name 
+#    street_suffix uk_country uk_county uk_postcode us_state us_state_abbr zip_code}.each do |m|
+#   eval("KathyLee::Fakes.add(:#{m}) {|*args| Faker::Address.#{m}(*args)}")
+# end
+# 
+# %w{bs catch_phrase name suffix}.each do |m|
+#   eval("KathyLee::Fakes.add(:#{m}) {|*args| Faker::Company.#{m}(*args)}")
+# end
+# 
+# %w{domain_name domain_suffix domain_word email free_email user_name}.each do |m|
+#   eval("KathyLee::Fakes.add(:#{m}) {|*args| Faker::Internet.#{m}(*args)}")
+# end
+# 
+# %w{paragraph paragraphs sentence sentences words}.each do |m|
+#   eval("KathyLee::Fakes.add(:#{m}) {|*args| Faker::Lorem.#{m}(*args)}")
+# end
+# 
+# %w{phone_number}.each do |m|
+#   eval("KathyLee::Fakes.add(:#{m}) {|*args| Faker::PhoneNumber.#{m}(*args)}")
+# end
+# 
+# KathyLee::Fakes.add(:url) {|*args| 'http://' + Faker::Internet.domain_name(*args)}
+# KathyLee::Fakes.add(:lorem) {|*args| Faker::Lorem.paragraphs(*args).join("\n")}
+# KathyLee::Fakes.add(:name) {|*args| Faker::Name.first_name + ' ' + Faker::Name.last_name}
+# KathyLee::Fakes.add(:birth_date) {|*args| (rand(80) + 13).years.ago}
+# KathyLee::Fakes.add(:title) {|*args| Faker::Company.catch_phrase.slice(0..250)}
+# KathyLee::Fakes.add(:username) {|*args| Faker::Internet.user_name}
+# KathyLee::Fakes.add(:company_name) {|*args| Faker::Company.name}
+# KathyLee::Fakes.alias(:login, :username)
+# KathyLee::Fakes.alias(:body, :lorem)
+# KathyLee::Fakes.alias(:full_name, :name)

data/lib/kathy_lee/kathy_lee.rb

@@ -1,15 +1,68 @@
-module KathyLee
+# Put your gem code here:
+
+class KathyLee
+  include Singleton
+  
+  attr_accessor :factories
+  attr_accessor :factory_attributes
+  
+  def initialize
+    self.factories = {}
+    self.factory_attributes = {}
+  end
+  
+  def build(factory_name, attributes = {})
+    if self.factories[factory_name.to_sym]
+      return self.factories[factory_name.to_sym].build(attributes)
+    else
+      self.define(factory_name, attributes) do
+        object = factory_name.to_s.classify.constantize.new(options)
+        object
+      end
+      self.build(factory_name, attributes)
+    end
+  end
+  
+  def create(factory_name, attributes = {})
+    object = self.build(factory_name, attributes)
+    object.save!
+    return object
+  end
+  
+  def attributes(factory_name, attributes = {}, &block)
+    if block_given?
+      self.factory_attributes[factory_name] = KathyLee::Attributes.new(attributes, &block)
+    end
+    if self.factory_attributes.has_key?(factory_name)
+      return self.factory_attributes[factory_name].process(attributes)
+    end
+    return nil
+  end
+  
+  def define(factory_name, attributes = {}, &block)
+    self.factories[factory_name.to_sym] = KathyLee::Definition.new(factory_name, attributes, &block)
+  end
+  
+  def sweatshop(factory_name, *options, count)
+    results = []
+    count.times do
+      results << self.build(factory_name, (options.first || {}))
+    end
+    return results
+  end
+  
+  def sweatshop!(factory_name, *options, count)
+    results = self.sweatshop(factory_name, *options, count)
+    results.each {|x| x.save!}
+    return results
+  end
   
   class << self
     
-    def const_missing(klass, for_klass = klass)
-      @klass = klass
-      @for_klass = for_klass
-      result = ERB.new(File.read(File.join(File.dirname(__FILE__), 'templates', 'proxy.html.erb'))).result(binding)
-      eval(result)
-      return "KathyLee::#{klass}".constantize
+    def method_missing(sym, *args, &block)
+      KathyLee.instance.send(sym, *args, &block)
     end
     
-  end # class << self
+  end
   
-end
+end

data/lib/kathy_lee.rb

@@ -1,16 +1,20 @@
 require 'singleton'
-require 'faker'
-require 'benchmark'
-require 'erb'
+require 'active_support'
+require 'dummy'
 
-class Symbol
-  
-  def classify
-    self.to_s.classify
+# A monkey patch for dummy:
+class Array
+  def rand
+    self[Kernel.rand(self.length)]
   end
-  
 end
 
-Dir.glob(File.join(File.dirname(__FILE__), 'kathy_lee', '**/*.rb')).each do |f|
-  require File.expand_path(f)
+
+path = File.join(File.dirname(__FILE__), 'kathy_lee')
+
+%w{kathy_lee definition definition/binding definition/relationship 
+   definition/has_one definition/has_many attributes attributes/binding fakes}.each do |file|
+  require File.expand_path(File.join(path, file))
 end
+
+# require File.join(File.dirname(__FILE__), 'generators', 'kathy_lee')

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: kathy_lee
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - markbates
@@ -9,21 +14,37 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-04 00:00:00 -05:00
+date: 2010-08-25 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: faker
+  name: activesupport
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: dummy
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.3.1
-    version: 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
 description: "kathy_lee was developed by: markbates"
-email: ""
+email: mark+kathylee@markbates.com
 executables: []
 
 extensions: []
@@ -32,18 +53,23 @@ extra_rdoc_files:
 - README
 - LICENSE
 files: 
-- lib/kathy_lee/errors/no_fake_registered.rb
+- lib/generators/kathy_lee/model/model_generator.rb
+- lib/generators/kathy_lee/model/templates/fixtures.rb
+- lib/generators/kathy_lee.rb
+- lib/kathy_lee/attributes/binding.rb
+- lib/kathy_lee/attributes.rb
+- lib/kathy_lee/definition/binding.rb
+- lib/kathy_lee/definition/has_many.rb
+- lib/kathy_lee/definition/has_one.rb
+- lib/kathy_lee/definition/relationship.rb
+- lib/kathy_lee/definition.rb
 - lib/kathy_lee/fakes.rb
 - lib/kathy_lee/kathy_lee.rb
-- lib/kathy_lee/proxy.rb
-- lib/kathy_lee/proxy_manager.rb
-- lib/kathy_lee/templates/proxy.html.erb
-- lib/kathy_lee/transaction.rb
 - lib/kathy_lee.rb
 - README
 - LICENSE
 has_rdoc: true
-homepage: ""
+homepage: http://www.metabates.com
 licenses: []
 
 post_install_message: 
@@ -52,21 +78,26 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: -2942405895079934725
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: magrathea
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: kathy_lee

data/lib/kathy_lee/errors/no_fake_registered.rb

@@ -1,11 +0,0 @@
-module KathyLee
-  module Errors
-    class NoFakeRegistered < StandardError
-      
-      def initialize(name)
-        super("No fake has been registered for '#{name}'!")
-      end
-      
-    end # NoFakeRegistered
-  end # Errors
-end # KathyLee

data/lib/kathy_lee/proxy.rb

@@ -1,113 +0,0 @@
-module KathyLee
-  class Proxy
-    attr_accessor :for
-    attr_accessor :attributes
-    attr_accessor :belongs_tos
-    attr_accessor :has_manys
-    
-    class << self
-      
-      def define(options = {}, &block)
-        KathyLee::ProxyManager.set_attributes(self, options, &block)
-      end
-      
-      def create(options = {})
-        model = self.new(options)
-        model.save!
-        return model
-      end
-      
-      def new(options = {})
-        proxy = super(options)
-        KathyLee::Transaction.execute do
-          proxy.build_new
-        end
-      end
-      
-      def sweatshop(count, options = {}, &block)
-        models = []
-        count.times do |i|
-          model = self.new(options)
-          yield model, i if block_given?
-          models << model
-        end
-        return models
-      end
-
-      def sweatshop!(count, &block)
-        nmodels = []
-        models = self.sweatshop(count, &block)
-        models.each do |m| 
-          m.save!
-          nmodels << m
-        end
-        return models
-      end
-      
-    end # class << self
-    
-    def initialize(options = {})
-      self.for = self.class.for
-      self.belongs_tos = {}
-      self.has_manys = {}
-      
-      opts = KathyLee::ProxyManager.get_attributes(self.class)
-      self.attributes = opts[:attributes]
-      instance_eval(&opts[:definition_block]) if opts[:definition_block]
-      self.attributes.merge!(options) if options.is_a?(Hash)
-    end
-    
-    def build_new
-      model = self.for.send(:new, self.attributes)
-      KathyLee::Transaction.register(model)
-      model = build_has_manys(model)
-      model = build_belongs_to(model)
-      return model
-    end
-    
-    def method_missing(sym, *args)
-      self.attributes[sym] = *args
-    end
-    
-    def belongs_to(owner, options = {})
-      self.belongs_tos[owner.to_sym] = options
-    end
-    
-    def has_many(things, options = {})
-      self.has_manys[things.to_sym] = options
-    end
-    
-    def fake(sym, *args)
-      KathyLee::Fakes.execute(sym, *args)
-    end
-    
-    protected
-    def build_has_manys(model)
-      hm = self.has_manys.dup
-      hm.each do |things, opts|
-        options = opts.dup
-        size = options.delete(:size) || 2
-        thing_klass = "::KathyLee::#{things.classify}".constantize
-        model.send("#{things}=", []) # clear out any parents versions of this
-        model.send(things) << thing_klass.sweatshop(size)
-      end
-      
-      return model
-    end
-    
-    def build_belongs_to(model)
-      bt = self.belongs_tos.dup
-      
-      bt.each do |owner, opts|
-        thing_klass = "::KathyLee::#{owner.classify}".constantize
-        thing = KathyLee::Transaction.get_model(thing_klass.for) do
-          thing_klass.new(opts)
-        end
-        model.send("#{owner}=", thing)
-      end
-      
-      return model
-    end
-    
-  end # Proxy
-end # KathyLee

data/lib/kathy_lee/proxy_manager.rb

@@ -1,34 +0,0 @@
-module KathyLee
-  class ProxyManager
-    include Singleton
-    
-    attr_accessor :proxies
-    
-    def initialize
-      self.reset!
-    end
-    
-    def reset!
-      self.proxies = {}
-    end
-    
-    def get_attributes(klass)
-      proxy = self.proxies[klass]
-      return proxy if proxy
-      return {:attributes => {}}
-    end
-    
-    def set_attributes(klass, attributes = {}, &block)
-      options = {:attributes => attributes}
-      options[:definition_block] = block if block_given?
-      self.proxies[klass] = options
-    end
-    
-    class << self
-      def method_missing(sym, *args, &block)
-        KathyLee::ProxyManager.instance.send(sym, *args, &block)
-      end
-    end # class << self
-    
-  end # ProxyManager
-end # KathyLee

data/lib/kathy_lee/templates/proxy.html.erb

@@ -1,15 +0,0 @@
-class KathyLee::<%= @klass %> < KathyLee::Proxy
-
-  class << self
-  
-    def for
-      ::<%= @for_klass %>
-    end
-    
-    def const_missing(klass, for_klass = <%= @klass %>)
-      KathyLee.const_missing(klass, for_klass)
-    end
-    
-  end
-  
-end

data/lib/kathy_lee/transaction.rb

@@ -1,51 +0,0 @@
-module KathyLee
-  class Transaction
-    include Singleton
-    
-    attr_accessor :started
-    attr_accessor :models
-    attr_accessor :transaction_id
-    
-    class << self
-      def method_missing(sym, *args, &block)
-        KathyLee::Transaction.instance.send(sym, *args, &block)
-      end
-    end
-    
-    def initialize
-      self.reset!
-    end
-    
-    def reset!
-      self.started = false
-      self.models = {}
-    end
-    
-    def register(model)
-      self.models[model.class.name.to_sym] = model
-    end
-    
-    def get_model(klass, &block)
-      model = self.models[klass.name.to_sym]
-      if block_given? && model.nil?
-        model = yield
-        self.register(model)
-      end
-      return model
-    end
-    
-    def execute(&block)
-      unless self.started
-        self.transaction_id = rand.to_s.gsub('0.', '')
-        self.started = true
-        results = yield if block_given?
-        self.reset!
-        return results
-      else
-        results = yield if block_given?
-        return results
-      end
-    end
-    
-  end # Transaction
-end # KathyLee