hat-trick 0.1.2 → 0.1.3

data/lib/hat_trick/controller_helpers.rb

@@ -28,7 +28,7 @@ module HatTrick
     end
 
     def model_class
-      return ht_wizard.model.class if ht_wizard.model
+      return hat_trick_wizard.model.class if hat_trick_wizard.model
 
       # if that didn't work, try to grab it from the params hash
       model_name = params_model_name
@@ -46,10 +46,21 @@ module HatTrick
 
     def setup_validation_group_for(wizard_step)
       klass = model_class
-      return if klass.nil?
+      if klass.nil?
+        Rails.logger.warn "model class was nil when setting up validation group for #{wizard_step}"
+        return
+      end
       step_name = wizard_step.name
       validation_groups = ::ActiveRecord::Base.validation_group_classes[klass] || []
-      unless validation_groups.include?(step_name)
+      dynamic_group_exists = HatTrick::ModelMethods.dynamic_validation_groups.include?(step_name)
+      static_validation_group_exists = validation_groups.include?(step_name) && !dynamic_group_exists
+      dynamic_validation_group = false
+
+      if static_validation_group_exists
+        Rails.logger.info "Not creating dynamic validation group for #{step_name} because a static one exists"
+      else
+        Rails.logger.info "Creating a dynamic validation group for #{step_name}"
+        dynamic_validation_group = true
         validation_fields = params.keys # TODO: Try it without these (so only the model keys below)
         model = model_key
         if model
@@ -58,7 +69,10 @@ module HatTrick
         validation_fields = validation_fields.map(&:to_sym)
         klass.validation_group(step_name, :fields => validation_fields)
       end
-      HatTrick::ModelMethods.set_current_validation_group_for(model_class, step_name)
+      Rails.logger.info "Setting current validation group for model class #{model_class} to #{step_name}"
+      HatTrick::ModelMethods.set_current_validation_group_for(model_class,
+                                                              step_name,
+                                                              dynamic_validation_group)
     end
   end
 end

data/lib/hat_trick/controller_hooks.rb

@@ -12,62 +12,76 @@ module HatTrick
 
     def self.def_action_method_aliases(action_methods)
       action_methods.each do |meth|
-        # Rails.logger.info "Aliasing #{meth}"
-        module_eval <<-RUBY_EVAL
-          def #{meth}_with_hat_trick(*args)
-            Rails.logger.info "#{meth}_with_hat_trick called"
-            #{meth}_hook(*args) if respond_to?("#{meth}_hook", :include_private)
-            common_hook(*args) if respond_to?(:common_hook, :include_private)
-            #{meth}_without_hat_trick(*args)
-          end
-          private "#{meth}_with_hat_trick"
-        RUBY_EVAL
+        unless respond_to?(:"#{meth}_with_hat_trick")
+          Rails.logger.info "Defining #{meth}_with_hat_trick"
+          module_eval <<-RUBY_EVAL
+            def #{meth}_with_hat_trick(*args)
+              Rails.logger.info "#{meth}_with_hat_trick called"
+              if respond_to?("#{meth}_hook", :include_private)
+                #{meth}_hook(*args)
+              end
+              common_hook(*args) if respond_to?(:common_hook, :include_private)
+              #{meth}_without_hat_trick(*args)
+            end
+            private "#{meth}_with_hat_trick"
+          RUBY_EVAL
+        end
       end
       true
     end
 
     private
 
+    def common_hook(*args)
+      Rails.logger.info "common_hook wizard instance: #{hat_trick_wizard.object_id}"
+    end
+
     def create_hook(*args)
-      setup_validation_group_for(ht_wizard.current_step)
+      setup_validation_group_for(hat_trick_wizard.current_step)
     end
 
     def update_hook(*args)
-      setup_validation_group_for(ht_wizard.current_step)
+      setup_validation_group_for(hat_trick_wizard.current_step)
     end
 
     def render_with_hat_trick(*args, &block)
       rendered = args.first
       if rendered && rendered.has_key?(:json)
-        model = rendered[:json]
-        ht_wizard.model = model
+        hat_trick_wizard.model = rendered[:json]
+      else
+        Rails.logger.warn "No model found in render args #{args.inspect}; model is #{hat_trick_wizard.model.inspect}"
       end
 
       if params.has_key?('_ht_meta')
-        next_step = params['_ht_meta']['next_step']
-        ht_wizard.advance_step(next_step)
+        next_step = params['_ht_step_link']
+        hat_trick_wizard.advance_step(next_step)
       end
 
       wizard_metadata = {
-        :url => ht_wizard.current_form_url,
-        :method => ht_wizard.current_form_method,
-        :currentStep => ht_wizard.current_step,
+        :externalRedirectURL => hat_trick_wizard.external_redirect_url,
+        :url => hat_trick_wizard.current_form_url,
+        :method => hat_trick_wizard.current_form_method,
+        :currentStep => hat_trick_wizard.current_step,
+        :percentComplete => hat_trick_wizard.percent_complete,
       }
 
-      include_data = ht_wizard.include_data
+      include_data = hat_trick_wizard.include_data
 
       # this sets the gon data (JS hatTrick object) for the initial page load
       gon.metadata = wizard_metadata
       gon.data = include_data
-      gon.model = ht_wizard.model
+      gon.model = hat_trick_wizard.model
 
       # this sets the wizard metadata for subsequent AJAX requests
-      if ht_wizard.model && rendered.has_key?(:json)
-        args[0][:json] = { :model => ht_wizard.model,
+      if hat_trick_wizard.model && rendered.has_key?(:json)
+        args[0][:json] = { :model => hat_trick_wizard.model,
                            :metadata => wizard_metadata }
         args[0][:json].merge!( :data => include_data )
       end
 
+      # unset redirects for subsequent steps
+      hat_trick_wizard.external_redirect_url = nil
+
       render_without_hat_trick(*args, &block)
     end
   end

data/lib/hat_trick/dsl.rb

@@ -6,37 +6,66 @@ module HatTrick
   module DSL
     extend ActiveSupport::Concern
 
-    attr_accessor :ht_wizard, :configure_callback, :_ht_config
+    attr_accessor :hat_trick_wizard
 
-    delegate :model, :previously_visited_step, :to => :ht_wizard
-
-    included do
-      alias_method_chain :initialize, :hat_trick
-    end
-
-    def initialize_with_hat_trick(*args)
-      @_ht_config = HatTrick::Config.new(self.class.wizard_def)
-      if configure_callback.is_a?(Proc)
-        ht_wizard.controller.instance_exec(@_ht_config, &configure_callback)
-      end
-      initialize_without_hat_trick(*args)
-    end
+    delegate :model, :previously_visited_step, :to => :hat_trick_wizard
 
     def next_step(name=nil)
       if name.nil?
         # getter
-        ht_wizard.next_step
+        hat_trick_wizard.next_step
       else
         # setter
-        step = ht_wizard.find_step(name)
+        step = hat_trick_wizard.find_step(name)
         # explicitly set steps should not be skipped
         step.skipped = false
-        ht_wizard.current_step.next_step = step
+        hat_trick_wizard.current_step.next_step = step
+      end
+    end
+
+    def previously_visited_step_name
+      if previously_visited_step.nil?
+        ''
+      else
+        previously_visited_step.name
       end
     end
 
     def skip_this_step
-      ht_wizard.skip_step(ht_wizard.current_step)
+      hat_trick_wizard.skip_step(hat_trick_wizard.current_step)
+    end
+
+    def button_to(step_name, options={})
+      button = self.class.send(:create_button_to, step_name, options)
+      hat_trick_wizard.current_step.add_button button
+    end
+
+    def remaining_step_count
+      hat_trick_wizard.steps_after_current
+    end
+
+    def adjust_remaining_step_count_by(diff)
+      hat_trick_wizard.steps_remaining += diff
+    end
+
+    def change_remaining_step_count_to(count)
+      hat_trick_wizard.steps_remaining = count
+    end
+
+    def total_step_count
+      hat_trick_wizard.total_step_count
+    end
+
+    def reset_step_count
+      hat_trick_wizard.override_step_count = nil
+    end
+
+    def redirect_to_step(step_name)
+      hat_trick_wizard.redirect_to_step step_name
+    end
+
+    def redirect_to_external_url(url)
+      hat_trick_wizard.external_redirect_url = url
     end
 
     module ClassMethods
@@ -47,7 +76,10 @@ module HatTrick
           include HatTrick::DSL::ControllerInstanceMethods
           include HatTrick::ControllerHooks
 
-          @wizard_def = HatTrick::WizardDefinition.new
+          ::ActiveRecord::Base.send(:include, HatTrick::ModelMethods)
+
+          config = HatTrick::Config.new
+          @wizard_def = HatTrick::WizardDefinition.new(config)
 
           yield
 
@@ -58,7 +90,15 @@ module HatTrick
 
       def configure(&block)
         raise "Must pass a block to configure" unless block_given?
-        @config_callback = block
+        self.configure_callback = block
+      end
+
+      def button_label(type, label)
+        wizard_def.config.send("#{type}_button_label=", label)
+      end
+
+      def button_label_i18n_key(type, i18n_key)
+        wizard_def.config.send("#{type}_button_label_i18n_key=", i18n_key)
       end
 
       def step(name, args={}, &block)
@@ -67,19 +107,6 @@ module HatTrick
         instance_eval &block if block_given?
       end
 
-      def repeat_step(name)
-        raise "repeat_step must be called from within a wizard block" unless wizard_def
-        repeated_step = wizard_def.find_step(name)
-        raise ArgumentError, "Couldn't find step named #{name}" unless repeated_step
-        new_step = repeated_step.dup
-        # use the repeated step's fieldset id
-        new_step.fieldset = repeated_step.fieldset
-        # but use the current step's name
-        new_step.name = wizard_def.last_step.name
-        # replace the step we're in the middle of defining w/ new_step
-        wizard_def.replace_step(wizard_def.last_step, new_step)
-      end
-
       def skip_this_step
         # skip_this_step in wizard definition (class) context means the step
         # can be explicitly jumped to, but won't be visited in the normal flow
@@ -87,27 +114,38 @@ module HatTrick
         wizard_def.last_step.skipped = true
       end
 
-      def button_to(name, options=nil)
-        raise "button_to must be called from within a wizard block" unless wizard_def
-        label = options[:label] if options
-        label ||= name.to_s.humanize
+      def last_step
+        raise "skip_this_step must be called from within a wizard block" unless wizard_def
+        wizard_def.last_step.last = true
+      end
 
-        id = options[:id] if options
+      def button_to(step_name, options={})
+        raise "button_to must be called from within a wizard block" unless wizard_def
+        wizard_def.last_step.add_button create_button_to(step_name, options)
+      end
 
+      def hide_button(button_type)
+        raise "before must be called from within a wizard block" unless wizard_def
         step = wizard_def.last_step
-        button = { :label => label }
-        button[:id] = id unless id.nil?
-        step.buttons = step.buttons.merge(name => button)
+        step.delete_button button_type
       end
 
-      def before(&block)
+      def before(scope=:current_step, &block)
         raise "before must be called from within a wizard block" unless wizard_def
-        wizard_def.last_step.before_callback = block
+        if scope == :each
+          wizard_def.before_callback_for_all_steps = block
+        else
+          wizard_def.last_step.before_callback = block
+        end
       end
 
-      def after(&block)
+      def after(scope=:current_step, &block)
         raise "after must be called from within a wizard block" unless wizard_def
-        wizard_def.last_step.after_callback = block
+        if scope == :each
+          wizard_def.after_callback_for_all_steps = block
+        else
+          wizard_def.last_step.after_callback = block
+        end
       end
 
       def include_data(key, &block)
@@ -117,10 +155,39 @@ module HatTrick
 
       def set_contents(&block)
         raise "set_contents must be called from within a wizard block" unless wizard_def
-        current_step_name = wizard_def.last_step.to_sym
-        include_data "hat_trick_step_contents" do |wiz, model|
-          { current_step_name => instance_exec(wiz, model, &block) }
+        wizard_def.last_step.step_contents_callback = block
+      end
+
+      private
+
+      def configure_callback
+        @configure_callback
+      end
+
+      def configure_callback=(block)
+        @configure_callback = block
+      end
+
+      def create_button_to(to_step_name, options={})
+        label = options[:label]
+        label ||= to_step_name.to_s.humanize
+
+        name = options[:name]
+        name ||= to_step_name.to_s.parameterize
+
+        value = options[:value]
+        value ||= to_step_name.to_s.parameterize
+
+        if options
+          id = options[:id]
+          css_class = options[:class]
         end
+
+        button = { :name => name, :value => value, :label => label }
+        button[:id] = id unless id.nil?
+        button[:class] = css_class unless css_class.nil?
+
+        { to_step_name => button }
       end
     end
 
@@ -131,15 +198,42 @@ module HatTrick
         before_filter :setup_wizard
       end
 
+      def back_to_start
+        respond_to do |format|
+          format.json { }
+        end
+      end
+
       private
 
       def setup_wizard
         wizard_def = self.class.instance_variable_get("@wizard_def")
-        @ht_wizard = wizard_def.get_wizard(self)
+        @hat_trick_wizard ||= wizard_def.make_wizard_for(self)
+
+        Rails.logger.info "setup_wizard wizard instance: #{@hat_trick_wizard.object_id}"
+
+        config_callback = self.class.send(:configure_callback)
+        if config_callback.is_a?(Proc)
+          instance_exec(wizard_def.config, &config_callback)
+        end
 
         if params.has_key?('_ht_meta')
           step_name = params['_ht_meta']['step']
-          @ht_wizard.current_step = step_name if step_name
+        end
+
+        # TODO: Setup the route that enables this in hat-trick automatically.
+        #       Currently done manually in the app.
+        if params.has_key?('step')
+          step_name = params['step']
+        end
+
+        if step_name.present?
+          Rails.logger.info "Setting current step to: #{step_name}"
+          begin
+            @hat_trick_wizard.current_step = step_name
+          rescue StepNotFound => e
+            raise ActionController::RoutingError, e.message
+          end
         end
       end
     end

data/lib/hat_trick/engine.rb

@@ -4,6 +4,12 @@ module HatTrick
   class Engine < ::Rails::Engine
     # just defining this causes Rails to look for assets inside this gem
 
+    initializer 'hat-trick.dsl' do
+      ActiveSupport.on_load(:action_controller) do
+        include HatTrick::DSL
+      end
+    end
+
     initializer 'hat-trick.form_helpers' do
       ActiveSupport.on_load(:action_view) do
         include HatTrick::FormHelper

data/lib/hat_trick/form_helper.rb

@@ -4,7 +4,7 @@ module HatTrick
       options = args.extract_options!
       options[:html] = { :class => 'wizard' }
 
-      wizard = controller.send(:ht_wizard)
+      wizard = controller.send(:hat_trick_wizard)
       wizard.start unless wizard.started?
 
       options[:url] = wizard.current_form_url

data/lib/hat_trick/model_methods.rb

@@ -2,6 +2,7 @@ module HatTrick
   module ModelMethods
     extend ActiveSupport::Concern
     mattr_accessor :validation_groups
+    mattr_accessor :dynamic_validation_groups
 
     attr_accessor :_dummy # so the dummy field will have something to set
 
@@ -10,9 +11,14 @@ module HatTrick
       alias_method_chain :as_json, :model_name if instance_methods.include?(:as_json)
     end
 
-    def self.set_current_validation_group_for(klass, validation_group_name)
+    def self.dynamic_validation_groups
+      @dynamic_validation_groups ||= []
+    end
+
+    def self.set_current_validation_group_for(klass, validation_group_name, dynamic)
       self.validation_groups ||= {}
       validation_groups[klass.to_s.underscore] = validation_group_name
+      dynamic_validation_groups << validation_group_name if dynamic
     end
 
     def self.current_validation_group_for(klass)
@@ -33,14 +39,19 @@ module HatTrick
     private
 
     # don't call this method 'current_validation_group', it conflicts with
-    # the gem
+    # the validation_group gem
     def current_step_validation_group
       HatTrick::ModelMethods.current_validation_group_for(self.class)
     end
 
     def enable_current_validation_group
       validation_group = current_step_validation_group
-      enable_validation_group validation_group if validation_group
+      if validation_group
+        Rails.logger.info "Enabling validation group #{validation_group}"
+        enable_validation_group validation_group
+      else
+        Rails.logger.info "NOT enabling a validation group"
+      end
     end
   end
 end

data/lib/hat_trick/step.rb

@@ -3,12 +3,16 @@ require 'hat_trick/step_definition'
 module HatTrick
   class Step
     attr_reader :step_def, :wizard
+    attr_accessor :next_step, :redirect_from
     attr_writer :skipped
-    attr_accessor :next_step
 
-    delegate :name, :fieldset, :buttons, :repeat_of, :to_sym, :to_s, :as_json,
-             :run_after_callback, :run_before_callback, :repeat?,
-             :run_include_data_callback, :include_data_key, :to => :step_def
+    delegate :name, :fieldset, :add_button, :buttons, :to_sym, :to_s,
+             :run_after_callback, :run_before_callback, :include_data,
+             :run_include_data_callback, :run_step_contents_callback,
+             :include_data_key, :config, :step_contents, :last?, :first?,
+             :to => :step_def
+
+    delegate :visited_steps, :skipped_steps, :to => :wizard
 
     def initialize(step_def, wizard)
       @step_def = step_def
@@ -16,20 +20,29 @@ module HatTrick
       @skipped = step_def.skipped?
     end
 
-    def session
-      wizard.session
+    def skipped?
+      @skipped || (skipped_steps.include?(self.to_sym) && !visited?)
     end
 
-    def skipped?
-      not visited? and @skipped
+    def redirect?
+      redirect_from.present?
     end
 
     def visited?
-      session["hat-trick.steps_visited"].include? self.to_sym
+      visited_steps.include? self.to_sym
+    end
+
+    def mark_as_visited
+      visited_steps << self.to_sym
     end
 
-    def visited=(_visited)
-      session["hat-trick.steps_visited"] << self.to_sym
+    def as_json(options = nil)
+      json = { :name => name, :fieldset => fieldset }
+      json[:buttons] = buttons.empty? ? [] : buttons
+      json[:first] = first?
+      json[:redirect] = redirect?
+      json[:redirectFrom] = redirect_from
+      json
     end
   end
 end