pat-maddox-fixjour 0.1.5

data/lib/core_ext/hash.rb

@@ -0,0 +1,9 @@
+class Hash
+  # Makes a hash able to be accessed via symbol or string keys.
+  def make_indifferent!
+    keys_values = self.dup
+    indifferent = Hash.new { |h,k| h[k.to_s] if Symbol === k }
+    replace(indifferent)
+    merge!(keys_values)
+  end
+end

data/lib/core_ext/object.rb

@@ -0,0 +1,6 @@
+class Object
+  def tap
+    yield self
+    self
+  end
+end

data/lib/fixjour/builders.rb

@@ -0,0 +1,80 @@
+module Fixjour
+  def counter(key=nil)
+    Counter.counter(key)
+  end
+
+  class << self
+    include Definitions
+
+    attr_accessor :allow_redundancy
+
+    # The list of classes that have builders defined.
+    def builders
+      @builders ||= Set.new
+    end
+
+    # This method should always return a valid instance of
+    # a model object.
+    def define_builder(klass, options={}, &block)
+      add_builder(klass)
+
+      if block_given?
+        define_new(klass, &block)
+      else
+        define_new(klass) do |proxy, overrides|
+          proxy.new(options.merge(overrides))
+        end
+      end
+
+      name = name_for(klass)
+
+      define_create(name)
+      define_valid_attributes(name)
+    end
+
+    # Adds builders to Fixjour.
+    def evaluate(&block)
+      begin
+        module_eval(&block)
+      rescue NameError => e
+        if e.name && evaluator.respond_to?(e.name)
+          raise NonBlockBuilderReference.new("You must use a builder block in order to reference other Fixjour creation methods.")
+        else
+          raise e
+        end
+      end
+    end
+
+    # 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)
+      end
+    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}")
+      end
+    end
+
+    def name_for(klass)
+      klass.name.underscore
+    end
+
+    # Anonymous class used for reflecting on current Fixjour state.
+    def evaluator
+      @evaluator ||= begin
+        klass = Class.new
+        klass.send :include, self
+        klass.new
+      end
+    end
+  end
+end

data/lib/fixjour/counter.rb

@@ -0,0 +1,30 @@
+module Fixjour
+  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 initialize
+      @value = 0
+    end
+
+    def next
+      @value += 1
+    end
+  end
+end

data/lib/fixjour/definitions.rb

@@ -0,0 +1,30 @@
+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!)
+      end
+    end
+  
+    # Defines the create_* method
+    def define_create(name)
+      define_method("create_#{name}") do |*args|
+        model = send("new_#{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
+        valid_attributes.delete_if { |key, value| value.nil? }
+        valid_attributes.stringify_keys!
+        valid_attributes.make_indifferent!
+        valid_attributes
+      end
+    end
+  end
+end

data/lib/fixjour/deprecation.rb

@@ -0,0 +1,24 @@
+module Fixjour
+  module Deprecation
+    module MergingProxy
+      def process(*args)
+        raise DeprecatedMergeAttempt.new(<<-END
+        You are attempting to call process on the class proxy.
+        This behavior was recently deprecated. In order to process
+        the overrides hash, pass two block arguments:
+
+          define_builder(Foo) do |klass, overrides|
+            overrides.process(:bar) do |bar|
+              overrides[:bar] = 'overridden'
+            end
+
+            klass.new(:name => 'fizz')
+          end
+        END
+        )
+      end
+    end
+  end
+end
+
+Fixjour::MergingProxy.send :include, Fixjour::Deprecation::MergingProxy

data/lib/fixjour/errors.rb

@@ -0,0 +1,33 @@
+module Fixjour
+  # Raised when a builder returns an invalid object.
+  class InvalidBuilder < StandardError; end
+  
+  # Raised when a builder will return an invalid object
+  # due to a validates_uniqueness_of validation.
+  class DangerousBuilder < StandardError; end
+  
+  # Raised when a builder returns an object that cannot
+  # be saved the database.
+  class UnsavableBuilder < StandardError; end
+  
+  # Raised when a builder returns an object of the wrong type
+  class WrongBuilderType < StandardError; end
+  
+  # Raised when a builder block saves the object.
+  class BuilderSavedRecord < StandardError; end
+  
+  # Raised when a Fixjour creation method is called in
+  # the wrong context.
+  class NonBlockBuilderReference < StandardError; end
+  
+  # Raised when a builder is defined for a class that already
+  # has one.
+  class RedundantBuilder < StandardError; end
+  
+  # Raised when a builder is defined with one block argument and
+  # the user assumes that it's the overrides hash. This used to
+  # be the standard behavior, but now blocks with one argument
+  # are passed the class proxy, and getting access to the overrides
+  # hash requires you pass two block arguments.
+  class DeprecatedMergeAttempt < StandardError; end
+end

data/lib/fixjour/generator.rb

@@ -0,0 +1,27 @@
+module Fixjour
+  # This generates a new instance of a model object for 
+  # the new_[model] method.
+  class Generator
+    attr_reader :klass, :block
+  
+    def initialize(klass, block)
+      @klass, @block = klass, block
+    end
+  
+    def call(context, overrides={})
+      overrides = OverridesHash.new(overrides)
+      result = block.bind(context).call(*args(overrides))
+      case result
+      when Hash then klass.new(result.merge(overrides))
+      else result
+      end
+    end
+  
+    def args(overrides)
+      case block.arity
+      when 1 then [MergingProxy.new(klass, overrides)]
+      when 2 then [MergingProxy.new(klass, overrides), overrides]
+      end
+    end
+  end
+end

data/lib/fixjour/merging_proxy.rb

@@ -0,0 +1,46 @@
+module Fixjour
+  # Proxy passed to builder blocks as first argument when a builder
+  # block takes two arguments. Automatically merges overrides when
+  # the #new method is called.
+  class MergingProxy
+    instance_methods.each { |m| undef_method(m) unless m =~ /__|inspect/ }
+    
+    def initialize(klass, overrides)
+      @klass = klass
+      @overrides = overrides
+    end
+    
+    def protected(*attrs)
+      attrs = attrs.empty? ?
+        @protected :
+        @protected = attrs
+      Set.new(attrs)
+    end
+  
+    def new(defaults={})
+      attrs = defaults.merge(@overrides)
+      accessible, inaccessible = partition(attrs)
+      
+      returning @klass.new(accessible) do |instance|
+        inaccessible.each do |key,val|
+          instance.send("#{key}=", val)
+        end
+      end
+    end
+    
+    def method_missing(sym, *args, &block)
+      @klass.respond_to?(sym) ? @klass.send(sym, *args, &block) : super
+    end
+    
+    private
+    
+    def partition(attrs)
+      accessible = attrs.keys.inject({ }) do |m, key|
+        next m if protected.include?(key)
+        m[key] = attrs.delete(key)
+        m
+      end
+      [accessible, attrs]
+    end
+  end
+end

data/lib/fixjour/overrides_hash.rb

@@ -0,0 +1,20 @@
+module Fixjour
+  # The overrides hash passed into each of the Fixjour
+  # methods is wrapped in this class to make the delete
+  # method private and add the ability to process.
+  class OverridesHash < Hash
+    private :delete
+    
+    def initialize(hash)
+      replace(hash)
+    end
+    
+    # Allows for processing of the overrides hash. Deletes
+    # the option when it's present, then yields the value.
+    def process(option)
+      delete(option).tap do |value|
+        yield value if value and block_given?
+      end
+    end
+  end
+end

data/lib/fixjour/redundant_check.rb

@@ -0,0 +1,29 @@
+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)
+          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

data/lib/fixjour/verify.rb

@@ -0,0 +1,54 @@
+module Fixjour
+  class << self
+    # Checks each builder to ensure that they:
+    #
+    # * Return valid objects
+    # * 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)
+
+        unless result.valid?
+          error(klass, InvalidBuilder, "returns an invalid object: #{result.errors.inspect}")
+        end
+
+        unless result.new_record?
+          error(klass, BuilderSavedRecord, "must return a new record")
+        end
+
+        unless result.is_a?(klass)
+          error(klass, WrongBuilderType, "must return an instance of #{klass}")
+        end
+
+        klass.transaction do
+          begin
+            result.save!
+          rescue => e
+            error(klass, UnsavableBuilder, "raises #{e.inspect} when saved to the database")
+          end
+        
+          unless new_record(klass).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)}")
+    end
+
+    private
+
+    def error(klass, exception, msg)
+      raise exception.new("The builder for #{klass} #{msg} ")
+    end
+  end
+end

data/lib/fixjour.rb

@@ -0,0 +1,25 @@
+$LOAD_PATH << File.dirname(__FILE__)
+
+require 'rubygems'
+require 'activerecord'
+require 'core_ext/hash'
+require 'core_ext/object'
+require 'fixjour/merging_proxy'
+require 'fixjour/redundant_check'
+require 'fixjour/overrides_hash'
+require 'fixjour/verify'
+require 'fixjour/errors'
+require 'fixjour/generator'
+require 'fixjour/definitions'
+require 'fixjour/counter'
+require 'fixjour/builders'
+require 'fixjour/deprecation'
+
+# This method is just for prettiness
+def Fixjour(options={}, &block)
+  return Fixjour unless block_given?
+  Fixjour.allow_redundancy = options[:allow_redundancy]
+  Fixjour.evaluate(&block)
+  Fixjour.verify! if options[:verify]
+  Fixjour.allow_redundancy = false
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: pat-maddox-fixjour
+version: !ruby/object:Gem::Version 
+  version: 0.1.5
+platform: ruby
+authors: 
+- Pat Nakajima
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-29 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: faker
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: acts_as_fu
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: patnakajima@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/core_ext
+- lib/core_ext/hash.rb
+- lib/core_ext/object.rb
+- lib/fixjour
+- lib/fixjour/builders.rb
+- lib/fixjour/counter.rb
+- lib/fixjour/definitions.rb
+- lib/fixjour/deprecation.rb
+- lib/fixjour/errors.rb
+- lib/fixjour/generator.rb
+- lib/fixjour/merging_proxy.rb
+- lib/fixjour/overrides_hash.rb
+- lib/fixjour/redundant_check.rb
+- lib/fixjour/verify.rb
+- lib/fixjour.rb
+has_rdoc: true
+homepage: http://github.com/nakajima/fixjour
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Object creation methods everyone already has
+test_files: []
+