fabrication 2.4.0 → 2.5.0

data/lib/fabrication.rb

@@ -8,6 +8,8 @@ module Fabrication
     autoload :Attribute,  'fabrication/schematic/attribute'
     autoload :Definition, 'fabrication/schematic/definition'
     autoload :Manager,    'fabrication/schematic/manager'
+    autoload :Evaluator,  'fabrication/schematic/evaluator'
+    autoload :Runner,     'fabrication/schematic/runner'
   end
 
   autoload :Config,     'fabrication/config'
@@ -23,6 +25,7 @@ module Fabrication
     autoload :DataMapper,   'fabrication/generator/data_mapper'
     autoload :Mongoid,      'fabrication/generator/mongoid'
     autoload :Sequel,       'fabrication/generator/sequel'
+    autoload :Keymaker,     'fabrication/generator/keymaker'
     autoload :Base,         'fabrication/generator/base'
   end
 

data/lib/fabrication/generator/base.rb

@@ -13,15 +13,19 @@ class Fabrication::Generator::Base
       build_instance
     end
 
-    callbacks[:after_build].each { |callback| callback.call(__instance) } if callbacks[:after_build]
+    execute_callbacks(callbacks[:after_build])
 
     __instance
   end
 
+  def execute_callbacks(callbacks)
+    callbacks.each { |callback| __instance.instance_eval(&callback) } if callbacks
+  end
+
   def create(attributes=[], callbacks=[])
     build(attributes, callbacks)
     persist
-    callbacks[:after_create].each { |callback| callback.call(__instance) } if callbacks[:after_create]
+    execute_callbacks(callbacks[:after_create])
     __instance
   end
 
@@ -64,13 +68,7 @@ class Fabrication::Generator::Base
   end
 
   def method_missing(method_name, *args, &block)
-    return __attributes[method_name] if args.empty? && !block_given? && __attributes[method_name]
-
-    if block_given?
-      assign(method_name, args.first || {}, &block)
-    else
-      assign(method_name, {}, args.first)
-    end
+    __attributes[method_name] || super
   end
 
   protected
@@ -85,34 +83,12 @@ class Fabrication::Generator::Base
     __instance.save! if __instance.respond_to?(:save!)
   end
 
-  def assign(method_name, options, value=nil, &block)
-    if options.has_key?(:count)
-      assign_collection(method_name, options[:count], value, &block)
-    else
-      assign_field(method_name, value, &block)
-    end
-  end
-
-  def assign_field(field_name, value, &block)
-    __attributes[field_name] = block_given? ? yield(__attributes) : value
-  end
-
-  def assign_collection(field_name, count, value, &block)
-    __attributes[field_name] = block_given? ?
-      (1..count).map { |i| yield(__attributes, i) } :
-      value * count
-  end
-
   def post_initialize; end
 
   def process_attributes(attributes)
     attributes.each do |attribute|
       __transient_fields << attribute.name if attribute.transient?
-      if Proc === attribute.value
-        method_missing(attribute.name, attribute.params, &attribute.value)
-      else
-        method_missing(attribute.name, attribute.value)
-      end
+      __attributes[attribute.name] = attribute.processed_value(__attributes)
     end
     __attributes.reject! { |k| __transient_fields.include?(k) }
   end

data/lib/fabrication/generator/keymaker.rb

@@ -0,0 +1,11 @@
+class Fabrication::Generator::Keymaker < Fabrication::Generator::Base
+
+  def self.supports?(klass)
+    defined?(Keymaker) && klass.ancestors.include?(Keymaker::Node)
+  end
+
+  def persist
+    __instance.save
+  end
+
+end

data/lib/fabrication/schematic/attribute.rb

@@ -1,8 +1,9 @@
 class Fabrication::Schematic::Attribute
 
-  attr_accessor :name, :params, :value
+  attr_accessor :klass, :name, :params, :value
 
-  def initialize(name, value, params={}, &block)
+  def initialize(klass, name, value, params={}, &block)
+    self.klass = klass
     self.name = name
     self.params = params
     self.value = value.nil? ? block : value
@@ -20,4 +21,23 @@ class Fabrication::Schematic::Attribute
     params[:transient]
   end
 
+  def processed_value(processed_attributes)
+    if count
+      (1..count).map { |i| execute(processed_attributes, i, &value) }
+    elsif value_proc?
+      execute(processed_attributes, &value)
+    else
+      value
+    end
+  end
+
+  private
+
+  def execute(*args, &block)
+    Fabrication::Schematic::Runner.new(klass).instance_exec(*args, &block)
+  end
+
+  def count; params[:count] end
+  def value_proc?; Proc === value end
+
 end

data/lib/fabrication/schematic/definition.rb

@@ -5,23 +5,18 @@ class Fabrication::Schematic::Definition
     Fabrication::Generator::DataMapper,
     Fabrication::Generator::Sequel,
     Fabrication::Generator::Mongoid,
+    Fabrication::Generator::Keymaker,
     Fabrication::Generator::Base
   ]
 
   attr_accessor :klass
   def initialize(klass, &block)
     self.klass = klass
-    instance_eval(&block) if block_given?
+    process_block(&block)
   end
 
-  def after_build(&block)
-    callbacks[:after_build] ||= []
-    callbacks[:after_build] << block
-  end
-
-  def after_create(&block)
-    callbacks[:after_create] ||= []
-    callbacks[:after_create] << block
+  def process_block(&block)
+    Fabrication::Schematic::Evaluator.new.process(self, &block) if block_given?
   end
 
   def attribute(name)
@@ -29,7 +24,7 @@ class Fabrication::Schematic::Definition
   end
 
   def append_or_update_attribute(attribute_name, value, params={}, &block)
-    attribute = Fabrication::Schematic::Attribute.new(attribute_name, value, params, &block)
+    attribute = Fabrication::Schematic::Attribute.new(klass, attribute_name, value, params, &block)
     if index = attributes.index { |a| a.name == attribute.name }
       attribute.transient! if attributes[index].transient?
       attributes[index] = attribute
@@ -86,53 +81,21 @@ class Fabrication::Schematic::Definition
     self.attributes = original.attributes.clone
   end
 
-  def init_with(*args)
-    args
-  end
-
   def merge(overrides={}, &block)
-    clone.tap do |schematic|
-      schematic.instance_eval(&block) if block_given?
+    clone.tap do |definition|
+      definition.process_block(&block)
       overrides.each do |name, value|
-        schematic.append_or_update_attribute(name.to_sym, value)
+        definition.append_or_update_attribute(name.to_sym, value)
       end
     end
   end
 
-  def method_missing(method_name, *args, &block)
-    params = Fabrication::Support.extract_options!(args)
-    value = args.first
-    block = generate_value(method_name, params) if args.empty? && !block_given?
-    append_or_update_attribute(method_name, value, params, &block)
-  end
-
-  def on_init(&block)
-    callbacks[:on_init] = block
-  end
-
-  def initialize_with(&block)
-    callbacks[:initialize_with] = block
-  end
-
-  def transient(*field_names)
-    field_names.each do |field_name|
-      append_or_update_attribute(field_name, nil, transient: true)
-    end
-  end
-
-  def sequence(name=Fabrication::Sequencer::DEFAULT, start=nil, &block)
-    name = "#{self.klass.to_s.downcase.gsub(/::/, '_')}_#{name}"
-    Fabrication::Sequencer.sequence(name, start, &block)
-  end
-
-  private
-
   def generate_value(name, params)
     if params[:count]
       name = name.to_s.singularize if name.to_s.respond_to?(:singularize)
-      Proc.new { Fabricate.build(params[:fabricator] || name) }
+      proc { Fabricate.build(params[:fabricator] || name) }
     else
-      Proc.new { Fabricate(params[:fabricator] || name) }
+      proc { Fabricate(params[:fabricator] || name) }
     end
   end
 end

data/lib/fabrication/schematic/evaluator.rb

@@ -0,0 +1,42 @@
+class Fabrication::Schematic::Evaluator < BasicObject
+
+  def process(definition, &block)
+    @_definition = definition
+    instance_eval(&block)
+  end
+
+  def method_missing(method_name, *args, &block)
+    params = ::Fabrication::Support.extract_options!(args)
+    value = args.first
+    block = @_definition.generate_value(method_name, params) if args.empty? && !block
+    @_definition.append_or_update_attribute(method_name, value, params, &block)
+  end
+
+  def after_build(&block)
+    @_definition.callbacks[:after_build] ||= []
+    @_definition.callbacks[:after_build] << block
+  end
+
+  def after_create(&block)
+    @_definition.callbacks[:after_create] ||= []
+    @_definition.callbacks[:after_create] << block
+  end
+
+  def on_init(&block)
+    @_definition.callbacks[:on_init] = block
+  end
+
+  def initialize_with(&block)
+    @_definition.callbacks[:initialize_with] = block
+  end
+
+  def init_with(*args)
+    args
+  end
+
+  def transient(*field_names)
+    field_names.each do |field_name|
+      @_definition.append_or_update_attribute(field_name, nil, transient: true)
+    end
+  end
+end

data/lib/fabrication/schematic/runner.rb

@@ -0,0 +1,13 @@
+class Fabrication::Schematic::Runner
+
+  attr_accessor :klass
+
+  def initialize(klass)
+    self.klass = klass
+  end
+
+  def sequence(name=Fabrication::Sequencer::DEFAULT, start=nil, &block)
+    name = "#{klass.to_s.downcase.gsub(/::/, '_')}_#{name}"
+    Fabrication::Sequencer.sequence(name, start, &block)
+  end
+end

data/lib/fabrication/version.rb

@@ -1,3 +1,3 @@
 module Fabrication
-  VERSION = '2.4.0'
+  VERSION = '2.5.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fabrication
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-13 00:00:00.000000000 Z
+date: 2012-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -171,6 +171,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: keymaker
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mongoid
   requirement: !ruby/object:Gem::Requirement
@@ -269,11 +285,14 @@ files:
 - lib/fabrication/generator/active_record.rb
 - lib/fabrication/generator/base.rb
 - lib/fabrication/generator/data_mapper.rb
+- lib/fabrication/generator/keymaker.rb
 - lib/fabrication/generator/mongoid.rb
 - lib/fabrication/generator/sequel.rb
 - lib/fabrication/schematic/attribute.rb
 - lib/fabrication/schematic/definition.rb
+- lib/fabrication/schematic/evaluator.rb
 - lib/fabrication/schematic/manager.rb
+- lib/fabrication/schematic/runner.rb
 - lib/fabrication/sequencer.rb
 - lib/fabrication/support.rb
 - lib/fabrication/syntax/make.rb