hat-trick 0.1.2 → 0.1.3

data/lib/hat_trick/step_definition.rb

@@ -1,8 +1,10 @@
 module HatTrick
   class StepDefinition
     attr_reader :callbacks, :include_data_key
-    attr_accessor :name, :fieldset, :buttons, :repeat_of
-    attr_writer :skipped
+    attr_accessor :name, :fieldset, :wizard
+    attr_writer :skipped, :first
+
+    delegate :config, :to => :wizard
 
     def initialize(args={})
       args.each_pair do |k,v|
@@ -12,15 +14,53 @@ module HatTrick
         end
       end
       @callbacks = {}
-      @buttons = {}
-      @skipped = false
+      @buttons = [
+        { next: default_button(:next) },
+        { back: default_button(:back) }
+      ]
+      @skipped ||= false
+      @last ||= false
+      @first ||= false
+    end
+
+    def buttons
+      # We should check for a new translation every time because the user may
+      # have changed their desired localization.
+      @buttons.map do |b|
+        button_type = b.keys.first
+        if b[button_type][:default]
+          b[button_type][:label] = button_label(button_type)
+        end
+        b
+      end
     end
 
-    def initialize_copy(source)
-      @callbacks = {}
-      @buttons = source.buttons.dup
-      @skipped = false
-      @repeat_of = source
+    def next_button
+      get_button(:next)
+    end
+
+    def back_button
+      get_button(:back)
+    end
+
+    def get_button(type)
+      button = buttons.detect { |b| b.keys.first == type.to_sym }
+      button[type.to_sym] unless button.nil?
+    end
+
+    def default_button(type)
+      { :label => button_label(type), :default => true }
+    end
+
+    def add_button(button)
+      @buttons.delete_if do |b|
+        b.keys.first == button.keys.first && b[b.keys.first][:default]
+      end
+      @buttons << button
+    end
+
+    def delete_button(type)
+      @buttons.delete_if { |b| b.keys.first == type }
     end
 
     def name=(name)
@@ -35,14 +75,27 @@ module HatTrick
       @fieldset or name
     end
 
-    def repeat?
-      !repeat_of.nil?
-    end
-
     def skipped?
       @skipped
     end
 
+    def last=(_last)
+      @last = _last
+      if @last
+        @buttons.delete_if { |b| b.keys.include?(:next) }
+      else
+        @buttons << { :next => default_next_button }
+      end
+    end
+
+    def last?
+      @last
+    end
+
+    def first?
+      @first
+    end
+
     def to_s
       str = "<HatTrick::Step:0x%08x :#{name}" % (object_id * 2)
       str += " fieldset: #{fieldset}" if fieldset != name
@@ -54,19 +107,12 @@ module HatTrick
       name.to_sym
     end
 
-    def as_json(options = nil)
-      json = { :name => name, :fieldset => fieldset }
-      json[:repeatOf] = repeat_of.as_json if repeat?
-      json[:buttons] = buttons unless buttons.empty?
-      json
-    end
-
-    def before_callback=(blk)
-      callbacks[:before] = blk
+    def before_callback=(block)
+      callbacks[:before] = block
     end
 
-    def after_callback=(blk)
-      callbacks[:after] = blk
+    def after_callback=(block)
+      callbacks[:after] = block
     end
 
     def include_data=(hash)
@@ -74,31 +120,111 @@ module HatTrick
       @include_data_key = hash.keys.first
     end
 
+    def step_contents_callback=(block)
+      callbacks[:step_contents] = block
+    end
+
+    def step_contents(context, model)
+      contents = run_step_contents_callback(context, model)
+      {
+        :hatTrickStepContents => {
+          name.to_s.camelize(:lower).to_sym => contents
+        }
+      }
+    end
+
+    def include_data(context, model)
+      inc_data = run_include_data_callback(context, model)
+      return {} unless inc_data.respond_to?(:as_json)
+      key = include_data_key.to_s.camelize(:lower)
+      { key => camelize_hash_keys(inc_data) }
+    end
+
+    def before_callbacks
+      before_callbacks = [callbacks[:before]]
+      if wizard.before_callback_for_all_steps
+        before_callbacks << wizard.before_callback_for_all_steps
+      end
+      before_callbacks
+    end
+
     def run_before_callback(context, model)
-      run_callback(:before, context, model)
+      Rails.logger.info "Running before callback for #{name}"
+      run_callbacks(before_callbacks, context, model)
     end
 
     def run_include_data_callback(context, model)
-      run_callback(:include_data, context, model)
+      run_callbacks([callbacks[:include_data]], context, model)
+    end
+
+    def run_step_contents_callback(context, model)
+      run_callbacks([callbacks[:step_contents]], context, model)
+    end
+
+    def after_callbacks
+      after_callbacks = [callbacks[:after]]
+      if wizard.after_callback_for_all_steps
+        after_callbacks << wizard.after_callback_for_all_steps
+      end
+      after_callbacks
     end
 
     def run_after_callback(context, model)
-      run_callback(:after, context, model)
+      run_callbacks(after_callbacks, context, model)
+    end
+
+    private
+
+    def button_label(type)
+      config.send("#{type}_button_label") or
+      if i18n_key = config.send("#{type}_button_label_i18n_key")
+        I18n.t i18n_key
+      end or
+      default_button_label(type)
     end
 
-    protected
+    def default_button_label(type)
+      translate_button_label(type)
+    end
 
-    def run_callback(type, context, model)
-      callback = callbacks[type.to_sym]
-      if callback && callback.is_a?(Proc)
-        if callback.arity > 0
-          unless model.is_a?(ActiveModel::Errors)
-            context.instance_exec model, &callback
+    def translate_button_label(type)
+      default_label = type.to_s.humanize
+      begin
+        label = I18n.t("wizard.buttons.#{type}", :default => default_label)
+      rescue NameError
+        label = default_label
+      end
+      label
+    end
+
+    def run_callbacks(callbacks, context, model)
+      result = nil
+      callbacks.each do |callback|
+        if callback && callback.is_a?(Proc)
+          if callback.arity > 0
+            unless model.nil? || model.is_a?(ActiveModel::Errors)
+              result = context.instance_exec model, &callback
+            end
+          else
+            result = context.instance_eval &callback
           end
-        else
-          context.instance_eval &callback
         end
       end
+
+      # return the last result; mainly for include_data
+      result
+    end
+
+    def camelize_hash_keys(_hash)
+      hash = {}
+      if _hash.respond_to?(:each)
+        _hash.each do |k,v|
+          hash[k.to_s.camelize(:lower)] = v
+        end
+      else
+        hash = _hash
+      end
+      hash
     end
   end
 end

data/lib/hat_trick/version.rb

@@ -1,3 +1,3 @@
 module HatTrick
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/hat_trick/wizard.rb

@@ -6,12 +6,15 @@ module HatTrick
   class Wizard
     include WizardSteps
 
-    attr_accessor :controller, :model
+    attr_accessor :controller, :model, :external_redirect_url
     attr_reader :current_step, :wizard_def, :steps
 
+    delegate :config, :to => :wizard_def
+
     def initialize(wizard_def)
       @wizard_def = wizard_def
       @steps = @wizard_def.steps.map { |s| HatTrick::Step.new(s, self) }
+      @current_step = first_step
     end
 
     def controller=(new_controller)
@@ -20,15 +23,12 @@ module HatTrick
 
     def model=(new_model)
       @model = new_model
-      unless @model.class.included_modules.include?(HatTrick::ModelMethods)
-        @model.class.send(:include, HatTrick::ModelMethods)
-      end
     end
 
     def current_step=(_step)
       raise "Don't set current_step to nil" if _step.nil?
       step = find_step(_step)
-      raise "#{step} is not a member of this wizard" unless step
+      raise StepNotFound, "#{_step} is not a member of this wizard" unless step
       @current_step = step
     end
 
@@ -72,7 +72,7 @@ module HatTrick
     def next_step
       step = find_next_step
       while step.skipped? do
-        step = find_step_after(step)
+        step = step_after(step)
       end
       step
     end
@@ -91,11 +91,64 @@ module HatTrick
     end
 
     def start
-      session["hat-trick.steps_visited"] = []
+      reset_step_session_data
       self.current_step ||= first_step
       run_before_callback
     end
 
+    def steps_before_current
+      steps_before(current_step)
+    end
+
+    def steps_after_current
+      steps_after(current_step)
+    end
+
+    def visited_steps
+      session["hat-trick.visited_steps"] ||= []
+    end
+
+    def skipped_steps
+      session["hat-trick.skipped_steps"] ||= []
+    end
+
+    def percent_complete(step=current_step)
+      percent = (steps_before_current.count.to_f / total_step_count) * 100
+      if percent > 100.0
+        100
+      elsif percent <= 0
+        0
+      elsif percent < 5.0
+        5
+      else
+        percent
+      end
+    end
+
+    def steps_remaining=(count)
+      self.override_step_count = steps_before_current.count + count
+    end
+
+    def steps_remaining
+      total_step_count - steps_before_current.count
+    end
+
+    def override_step_count=(count)
+      if count.nil?
+        session.delete('hat-trick.override_step_count')
+      else
+        session['hat-trick.override_step_count'] = count
+      end
+    end
+
+    def override_step_count
+      session['hat-trick.override_step_count']
+    end
+
+    def total_step_count
+      override_step_count or steps.count
+    end
+
     def run_before_callback(step=current_step)
       step.run_before_callback(controller, model)
     end
@@ -104,13 +157,29 @@ module HatTrick
       step.run_after_callback(controller, model)
     end
 
+    def redirect_to_step(step)
+      redirect_from = current_step.fieldset
+      self.current_step = step
+      current_step.redirect_from = redirect_from
+    end
+
     def advance_step(next_step_name=nil)
       # clean up current step
-      current_step.visited = true
+      current_step.mark_as_visited
+      before_callback_next_step = current_step.next_step
       run_after_callback
+      after_callback_next_step = current_step.next_step
 
-      # see if there is a requested next step
-      requested_next_step = find_step(next_step_name) unless next_step_name.nil?
+      # return if any redirects were requested
+      return if external_redirect_url.present?
+
+      # if after callback changed the next step, go to that one
+      requested_next_step = if after_callback_next_step != before_callback_next_step
+        after_callback_next_step
+      else
+        # use argument, if there was one
+        find_step(next_step_name) unless next_step_name.nil?
+      end
 
       # finish if we're on the last step
       if current_step == last_step && !requested_next_step
@@ -122,72 +191,62 @@ module HatTrick
           run_before_callback
           # if the step was explicitly requested, we ignore #skipped?
         else
-          Rails.logger.info "Advancing to step: #{next_step}"
           self.current_step = next_step
           run_before_callback
           # Running the before callback may have marked current_step as skipped
           while current_step.skipped?
             self.current_step = next_step
             run_before_callback
+            # make sure we don't loop forever
+            break if current_step == last_step
           end
+          Rails.logger.info "Advancing to step: #{current_step}"
         end
       end
     end
 
     def include_data
+      include_data_for_step(current_step)
+    end
+
+    def include_data_for_step(step)
       return {} if model.nil?
-      inc_data = {}
-      include_data_steps = steps_before(current_step).reject(&:skipped?) << current_step
-      include_data_steps.each do |step|
-        step_data = step.run_include_data_callback(controller, model)
-        next if step_data.nil? || !step_data.respond_to?(:as_json)
-        step_key = step.include_data_key.to_s.camelize(:lower)
-        begin
-          inc_data[step_key] = camelize_hash_keys(step_data)
-        rescue NoMethodError => e
-          Rails.logger.error "Unable to serialize data for step #{step}: #{e}"
-        end
-      end
+      inc_data = step.include_data(controller, model)
+      contents = step.step_contents(controller, model)
+      inc_data.merge! contents
+      inc_data.delete_if { |k,v| v.nil? }
       inc_data
     end
 
     def alias_action_methods
       action_methods = controller.action_methods.reject do |m|
-        /^render/ =~ m.to_s ||
-        controller.respond_to?("#{m}_with_hat_trick", :include_private)
+        /^render/ =~ m.to_s or
+        m.to_s.include?('!') or
+        controller.respond_to?("#{m}_without_hat_trick", :include_private)
       end
       HatTrick::ControllerHooks.def_action_method_aliases(action_methods)
-      action_methods.each do |meth|
-        controller.class.send(:alias_method_chain, meth, :hat_trick)
-        controller.class.send(:private, "#{meth}_without_hat_trick")
+      action_methods.each do |m|
+        Rails.logger.info "Aliasing #{m}"
+        controller.class.send(:alias_method_chain, m, :hat_trick)
+        controller.class.send(:private, "#{m}_without_hat_trick")
       end
     end
 
     private
 
+    def reset_step_session_data
+      # TODO: Move this into a StepCollection class (maybe subclass Set)
+      visited_steps = []
+      skipped_steps = []
+    end
+
     def fake_session
+      Rails.logger.warn "Using a fake session object!"
       @fake_session ||= {}
     end
 
     def find_next_step
-      find_step(current_step.next_step) or find_step_after(current_step)
-    end
-
-    def find_step_after(step)
-      next_path_step = step_after step
-      next_path_step or find_next_active_step(step)
-    end
-
-    def camelize_hash_keys(_hash)
-      hash = {}
-      if _hash.respond_to?(:each)
-        _hash.each do |k,v|
-          hash[k.to_s.camelize(:lower)] = v
-        end
-      else
-        hash = _hash
-      end
-      hash
+      find_step(current_step.next_step) || step_after(current_step)
     end
   end
 end

data/lib/hat_trick/wizard_definition.rb

@@ -6,19 +6,28 @@ module HatTrick
   class WizardDefinition
     include WizardSteps
 
-    attr_accessor :configured_create_url, :configured_update_url
+    attr_reader :config
+    attr_accessor :before_callback_for_all_steps, :after_callback_for_all_steps
 
-    def initialize
+    def initialize(config)
+      @config = config
       @steps = []
     end
 
-    def get_wizard(controller)
-      controller.send(:ht_wizard) or (
-        wizard = HatTrick::Wizard.new(self)
-        wizard.controller = controller
-        wizard.alias_action_methods
-        wizard
-      )
+    def make_wizard_for(controller)
+      Rails.logger.info "Making new wizard instance"
+      wizard = HatTrick::Wizard.new(self)
+      wizard.controller = controller
+      wizard.alias_action_methods
+      wizard
+    end
+
+    def configured_create_url
+      config.create_url
+    end
+
+    def configured_update_url
+      config.update_url
     end
   end
 end

data/lib/hat_trick/wizard_steps.rb

@@ -1,4 +1,6 @@
 module HatTrick
+  class StepNotFound < StandardError; end
+
   module WizardSteps
     include Enumerable
     attr_reader :steps
@@ -26,9 +28,11 @@ module HatTrick
     def steps_after(_step)
       step = find_step(_step)
       return [] unless step
+      return [] if step.last? && !step.skipped?
       step_index = steps.index(step)
       max_index = steps.count - 1
-      after_index = step_index < max_index ? step_index + 1 : step_index
+      return [] if step_index >= max_index
+      after_index = step_index + 1
       steps[after_index .. -1]
     end
 
@@ -40,7 +44,8 @@ module HatTrick
       step = find_step(_step)
       return [] unless step
       step_index = steps.index(step)
-      before_index = step_index > 0 ? step_index - 1 : step_index
+      return [] if step_index <= 0
+      before_index = step_index - 1
       steps[0 .. before_index]
     end
 
@@ -48,10 +53,14 @@ module HatTrick
       if step.is_a?(HatTrick::Step) || step.is_a?(HatTrick::StepDefinition)
         new_step = step
       else
-        step_args = args.merge(:name => step)
+        step_args = args.merge(:name => step, :wizard => self)
         new_step = HatTrick::StepDefinition.new(step_args)
       end
 
+      if steps.count == 0
+        new_step.first = true
+      end
+
       steps << new_step
 
       new_step

data/spec/lib/hat_trick/dsl_spec.rb

@@ -1,26 +1,27 @@
 require 'spec_helper'
 
-# will automatically get HatTrick::DSL included
-class FakeController < ActionController::Base; end
-
 describe HatTrick::DSL do
-  let(:controller_class) { FakeController }
+  subject(:controller) {
+    Class.new.send(:include, HatTrick::DSL).tap do |c|
+      c.stubs(:before_filter)
+      c.any_instance.stubs(:render)
+    end
+  }
 
-  # save some typing
-  def dsl(&block)
-    controller_class.instance_eval &block
-  end
-  
   describe HatTrick::DSL::ClassMethods do
     describe "#step" do
       it "should call Wizard#add_step" do
         HatTrick::WizardDefinition.any_instance.expects(:add_step).with(:foo, {})
-        dsl do
+        controller.instance_eval do
           wizard do
             step :foo
           end
         end
       end
+
+      it "raises an error if called outside a wizard block" do
+        expect { controller.step :foo }.to raise_error
+      end
     end
   end
 end