fixjour 0.1.5 → 0.1.6

data/lib/fixjour/builder.rb

@@ -0,0 +1,21 @@
+module Fixjour
+  class Builder
+    attr_reader :klass
+
+    def initialize(klass, options={})
+      @klass, @options = klass, options
+    end
+
+    def name
+      @name ||= (@options[:as] || @klass.name.underscore).to_s
+    end
+
+    def eql?(other)
+      @klass == other.klass
+    end
+
+    def hash
+      @klass.hash
+    end
+  end
+end

data/lib/fixjour/builders.rb

@@ -1,5 +1,8 @@
 module Fixjour
-  include Counter
+  def counter(key=nil)
+    Counter.counter(key)
+  end
+
   class << self
     include Definitions
 
@@ -13,20 +16,19 @@ module Fixjour
     # This method should always return a valid instance of
     # a model object.
     def define_builder(klass, options={}, &block)
-      add_builder(klass)
+      builder = Builder.new(klass, :as => options.delete(:as))
+      add_builder(builder)
 
       if block_given?
-        define_new(klass, &block)
+        define_new(builder, &block)
       else
-        define_new(klass) do |proxy, overrides|
+        define_new(builder) do |proxy, overrides|
           proxy.new(options.merge(overrides))
         end
       end
 
-      name = name_for(klass)
-
-      define_create(name)
-      define_valid_attributes(name)
+      define_create(builder)
+      define_valid_attributes(builder)
     end
 
     # Adds builders to Fixjour.
@@ -45,19 +47,24 @@ module Fixjour
     # Checks to see whether or not a builder is defined. Duh.
     def builder_defined?(builder)
       case builder
-      when Class          then builders.include?(builders)
-      when String, Symbol then builders.map(&:name).include?(builder)
+      when Class  then builders.map(&:klass).include?(builders)
+      when String then builders.map(&:name).include?(builder)
+      when Symbol then builders.map(&:name).include?(builder.to_s)
       end
     end
 
+    def remove(builder)
+      builders.delete(Builder.new(builder))
+    end
+
     private
 
     # Registers a class' builder. This allows us to make sure
     # redundant builders aren't defined, which can lead to confusion
     # when trying to figure out where objects are being created.
-    def add_builder(klass)
-      unless builders.add?(klass) or Fixjour.allow_redundancy
-        raise RedundantBuilder.new("You already defined a builder for #{klass.inspect}")
+    def add_builder(builder)
+      unless builders.add?(builder) or Fixjour.allow_redundancy
+        raise RedundantBuilder.new("You already defined a builder for #{builder.klass.inspect}")
       end
     end
 

data/lib/fixjour/counter.rb

@@ -1,20 +1,30 @@
 module Fixjour
-  module Counter
-    def self.reset(key=nil)
-      if key
-        @counters[key] = lambda { s ||= 0; s += 1 }
-      else
-        @counters = Hash.new { |h,k| s ||= 0; c = lambda { s += 1 }; h[k] = c }
+  class Counter
+    class << self
+      def reset(key=nil)
+        key ? counters.delete(key) : counters.clear
+      end
+
+      def counter(key)
+        counters[key] ||= new
+        counters[key].next
+      end
+
+      private
+
+      def counters
+        @counters ||= {}
       end
     end
+
     reset
 
-    def self.counter(key)
-      @counters[key][]
+    def initialize
+      @value = 0
     end
 
-    def counter(key=nil)
-      Counter.counter(key)
+    def next
+      @value += 1
     end
   end
 end

data/lib/fixjour/definitions.rb

@@ -1,25 +1,25 @@
 module Fixjour
   module Definitions
     # Defines the new_* method
-    def define_new(klass, &block)
-      define_method("new_#{name_for(klass)}") do |*args|
-        Generator.new(klass, block).call(self, args.extract_options!.symbolize_keys!)
+    def define_new(builder, &block)
+      define_method("new_#{builder.name}") do |*args|
+        Generator.new(builder.klass, block).call(self, args.extract_options!.symbolize_keys!)
       end
     end
   
     # Defines the create_* method
-    def define_create(name)
-      define_method("create_#{name}") do |*args|
-        model = send("new_#{name}", *args)
+    def define_create(builder)
+      define_method("create_#{builder.name}") do |*args|
+        model = send("new_#{builder.name}", *args)
         model.save!
         model
       end
     end
   
     # Defines the valid_*_attributes method
-    def define_valid_attributes(name)
-      define_method("valid_#{name}_attributes") do |*args|
-        valid_attributes = send("new_#{name}", *args).attributes
+    def define_valid_attributes(builder)
+      define_method("valid_#{builder.name}_attributes") do |*args|
+        valid_attributes = send("new_#{builder.name}", *args).attributes
         valid_attributes.delete_if { |key, value| value.nil? }
         valid_attributes.stringify_keys!
         valid_attributes.make_indifferent!

data/lib/fixjour/redundant_check.rb

@@ -2,28 +2,27 @@ module Fixjour
   def self.included(klass)
     klass.extend(RedundancyChecker)
   end
-  
+
   # Uses method_added hook to make sure no redundant builder methods
   # get defined after a builder has already created them. For example,
   # if you have a Comment builder, this hook will ensure that any attempt
   # to define a #new_comment method will raise an exception.
   module RedundancyChecker
     BUILDER_METHOD_PATTERN = /^(new|create|valid)_(\w+)(_attributes)?$/
-    
+
     def method_added(sym)
       name = sym.to_s
-      
       if klass_name = get_klass_name(name)
-        if Fixjour.builder_defined?(klass_name)
+        if Fixjour.builder_defined?(klass_name.underscore)
           raise RedundantBuilder.new("You already defined a builder for #{inspect}")
         end
       end
     end
-    
+
     def get_klass_name(name)
       if match = name.match(BUILDER_METHOD_PATTERN)
         match[2].classify.gsub(/Attribute$/, '')
       end
     end
   end
-end
+end

data/lib/fixjour/verify.rb

@@ -6,8 +6,9 @@ module Fixjour
     # * The new_* methods return new records
     # * The creation methods return objects of the proper type
     def verify!
-      builders.each do |klass|
-        result = new_record(klass)
+      builders.each do |builder|
+        klass = builder.klass
+        result = new_record(builder)
 
         unless result.valid?
           error(klass, InvalidBuilder, "returns an invalid object: #{result.errors.inspect}")
@@ -27,22 +28,22 @@ module Fixjour
           rescue => e
             error(klass, UnsavableBuilder, "raises #{e.inspect} when saved to the database")
           end
-        
-          unless new_record(klass).valid?
+
+          unless new_record(builder).valid?
             msg = ""
             msg << "returns invalid an invalid object after another object has been saved.\n"
             msg << "This could be caused by a validates_uniqueness_of validation in your model.\n"
             msg << "Use something like the faker gem to alleviate this issue."
             error(klass, DangerousBuilder, msg)
           end
-          
+
           raise ActiveRecord::Rollback
         end
       end
     end
 
     def new_record(klass)
-      evaluator.send("new_#{name_for(klass)}")
+      evaluator.send("new_#{klass.name}")
     end
 
     private
@@ -51,4 +52,4 @@ module Fixjour
       raise exception.new("The builder for #{klass} #{msg} ")
     end
   end
-end
+end

data/lib/fixjour.rb

@@ -12,6 +12,7 @@ require 'fixjour/errors'
 require 'fixjour/generator'
 require 'fixjour/definitions'
 require 'fixjour/counter'
+require 'fixjour/builder'
 require 'fixjour/builders'
 require 'fixjour/deprecation'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: fixjour
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors: 
 - Pat Nakajima
@@ -35,6 +35,7 @@ files:
 - lib/core_ext/hash.rb
 - lib/core_ext/object.rb
 - lib/fixjour
+- lib/fixjour/builder.rb
 - lib/fixjour/builders.rb
 - lib/fixjour/counter.rb
 - lib/fixjour/definitions.rb