lib/data_miner/configuration.rb in data_miner-0.4.17 vs lib/data_miner/configuration.rb in data_miner-0.4.18

@@ -1,72 +1,77 @@
 module DataMiner
   class Configuration
     include Blockenspiel::DSL
     
-    attr_accessor :resource, :runnables, :runnable_counter, :attributes
+    attr_accessor :resource, :steps, :step_counter, :attributes
 
     def initialize(resource)
-      @runnables = Array.new
+      @steps = Array.new
       @resource = resource
-      @runnable_counter = 0
+      @step_counter = 0
       @attributes = HashWithIndifferentAccess.new
     end
     
     def process(method_name_or_block_description, &block)
-      runnables << DataMiner::Process.new(self, runnable_counter, method_name_or_block_description, &block)
-      self.runnable_counter += 1
+      steps << DataMiner::Process.new(self, step_counter, method_name_or_block_description, &block)
+      self.step_counter += 1
     end
 
     def clone(description, options = {})
-      runnables << DataMiner::Clone.new(self, runnable_counter, description, options)
-      self.runnable_counter += 1
+      steps << DataMiner::Clone.new(self, step_counter, description, options)
+      self.step_counter += 1
     end
 
     def import(*args, &block)
       if args.length == 1
         description = '(no description)'
       else
         description = args.first
       end
       options = args.last
         
-      runnable = DataMiner::Import.new self, runnable_counter, description, options
-      Blockenspiel.invoke block, runnable
-      runnables << runnable
-      self.runnable_counter += 1
+      step = DataMiner::Import.new self, step_counter, description, options
+      Blockenspiel.invoke block, step
+      steps << step
+      self.step_counter += 1
     end
 
     # Mine data for this class.
     def run(options = {})
       options.symbolize_keys!
       
+      return if DataMiner::Configuration.call_stack.include? resource.name
+      DataMiner::Configuration.call_stack.push resource.name
+      
       finished = false
       if DataMiner::Run.table_exists?
         run = DataMiner::Run.create! :started_at => Time.now, :resource_name => resource.name if DataMiner::Run.table_exists?
       else
         run = nil
         DataMiner.log_info "Not logging individual runs. Please run DataMiner::Run.create_tables if you want to enable this."
       end
       resource.delete_all if options[:from_scratch]
       begin
-        runnables.each { |runnable| runnable.run run }
+        steps.each { |step| step.run run }
         finished = true
       ensure
         run.update_attributes! :ended_at => Time.now, :finished => finished if DataMiner::Run.table_exists?
+        DataMiner::Configuration.call_stack.clear if DataMiner::Configuration.call_stack.first == resource.name
       end
       nil
     end
     
-    def import_runnables
-      runnables.select { |runnable| runnable.is_a? Import }
+    def import_steps
+      steps.select { |step| step.is_a? Import }
     end
     
     def before_invoke
       
     end
     
     def after_invoke
+      return unless resource.table_exists?
       make_sure_unit_definitions_make_sense
       suggest_missing_column_migrations
     end
     
     COMPLETE_UNIT_DEFINITIONS = [
@@ -77,12 +82,12 @@
       [:units_field_number],
       [:units_field_number, :to_units]
     ]
     
     def make_sure_unit_definitions_make_sense
-      import_runnables.each do |runnable|
-        runnable.attributes.each do |_, attribute|
+      import_steps.each do |step|
+        step.attributes.each do |_, attribute|
           if attribute.options.any? { |k, _| k.to_s =~ /unit/ } and COMPLETE_UNIT_DEFINITIONS.none? { |complete_definition| complete_definition.all? { |required_option| attribute.options[required_option].present? } }
             DataMiner.log_or_raise %{
 
 ================================
 
@@ -109,12 +114,12 @@
       unless resource.column_names.include?('data_miner_last_run_id')
         non_essential_missing_columns << 'data_miner_last_run_id'
         DataMiner.log_info "Not recording which run touched a row."
       end
       
-      import_runnables.each do |runnable|
-        runnable.attributes.each do |_, attribute|
+      import_steps.each do |step|
+        step.attributes.each do |_, attribute|
           DataMiner.log_or_raise "You can't have an attribute column that ends in _units (reserved): #{resource.table_name}.#{attribute.name}" if attribute.name.ends_with? '_units'
           unless resource.column_names.include? attribute.name
             missing_columns << attribute.name
           end
           if attribute.wants_units? and !resource.column_names.include?(units_column = "#{attribute.name}_units")
@@ -158,9 +163,12 @@
       end
     end
     
     cattr_accessor :resource_names
     self.resource_names = Array.new
+    
+    cattr_accessor :call_stack
+    self.call_stack = Array.new
     class << self
       # Mine data. Defaults to all resource_names touched by DataMiner.
       #
       # Options
       # * <tt>:resource_names</tt>: array of resource (class) names to mine