hat-trick 0.0.1 → 0.1.0

data/lib/hat_trick/controller_hooks.rb

@@ -1,8 +1,10 @@
 require 'hat_trick/model_methods'
+require 'hat_trick/controller_helpers'
 
 module HatTrick
   module ControllerHooks
     extend ActiveSupport::Concern
+    include ControllerHelpers
 
     included do
       alias_method_chain :render, :hat_trick
@@ -10,12 +12,12 @@ module HatTrick
 
     def self.def_action_method_aliases(action_methods)
       action_methods.each do |meth|
-        Rails.logger.info "Aliasing #{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)
+            common_hook(*args) if respond_to?(:common_hook, :include_private)
             #{meth}_without_hat_trick(*args)
           end
           private "#{meth}_with_hat_trick"
@@ -26,53 +28,6 @@ module HatTrick
 
     private
 
-    def params_model_name
-      params.each do |k,v|
-        return class_name(k) if v.is_a?(Hash) && is_model?(k)
-      end
-      nil
-    end
-
-    def is_model?(model_name)
-      begin
-        class_name(model_name).constantize
-      rescue NameError
-        return false
-      end
-      true
-    end
-
-    def class_name(hash_key)
-      hash_key.to_s.camelize
-    end
-
-    def model_class
-      model_name = params_model_name
-      return nil if model_name.nil?
-      begin
-        model_class = params_model_name.constantize
-      rescue NameError
-        Rails.logger.error "Could not find model class #{params_model_name.camelize}"
-        nil
-      else
-        model_class
-      end
-    end
-
-    def setup_validation_group_for(wizard_step)
-      klass = model_class
-      return if klass.nil?
-      step_name = wizard_step.name
-      validation_groups = ::ActiveRecord::Base.validation_group_classes[klass] || []
-      unless validation_groups.include?(step_name)
-        klass.validation_group(step_name, :fields => params.keys)
-      end
-      HatTrick::ModelMethods.set_current_validation_group_for(model_class, step_name)
-      unless klass.included_modules.include?(HatTrick::ModelMethods)
-        klass.send(:include, HatTrick::ModelMethods)
-      end
-    end
-
     def create_hook(*args)
       setup_validation_group_for(ht_wizard.current_step)
     end
@@ -81,13 +36,10 @@ module HatTrick
       setup_validation_group_for(ht_wizard.current_step)
     end
 
-    def common_hook(*args)
-      # nothing here for now
-    end
-
-    def render_with_hat_trick(*args)
-      if args.first.has_key?(:json)
-        model = args[0][:json]
+    def render_with_hat_trick(*args, &block)
+      rendered = args.first
+      if rendered && rendered.has_key?(:json)
+        model = rendered[:json]
         ht_wizard.model = model
       end
 
@@ -102,17 +54,21 @@ module HatTrick
         :currentStep => ht_wizard.current_step,
       }
 
-      # this sets the wizard_metadata for the initial page load
-      gon.wizard_metadata = wizard_metadata
+      include_data = ht_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
 
-      if ht_wizard.model && args[0].has_key?(:json)
-        # this sets the wizard metadata for subsequent AJAX requests
-        args[0][:json] = { :formModel => ht_wizard.model,
-                           :wizardMetadata => wizard_metadata }
-        args[0][:json].merge! ht_wizard.include_data
+      # this sets the wizard metadata for subsequent AJAX requests
+      if ht_wizard.model && rendered.has_key?(:json)
+        args[0][:json] = { :model => ht_wizard.model,
+                           :metadata => wizard_metadata }
+        args[0][:json].merge!( :data => include_data )
       end
 
-      render_without_hat_trick(*args)
+      render_without_hat_trick(*args, &block)
     end
   end
 end

data/lib/hat_trick/dsl.rb

@@ -1,75 +1,74 @@
 require 'hat_trick/wizard_definition'
 require 'hat_trick/controller_hooks'
+require 'hat_trick/config'
 
 module HatTrick
   module DSL
     extend ActiveSupport::Concern
 
-    module ClassMethods
-      def wizard(&block)
-        if block_given?
-          include HatTrick::DSL::ControllerInstanceMethods
-          include HatTrick::ControllerHooks
+    attr_accessor :ht_wizard, :configure_callback, :_ht_config
 
-          @wizard_def = HatTrick::WizardDefinition.new
+    delegate :model, :previously_visited_step, :to => :ht_wizard
 
-          @wizard_dsl = HatTrick::DSL::WizardContext.new(@wizard_def)
-          @wizard_dsl.instance_eval &block
+    included do
+      alias_method_chain :initialize, :hat_trick
+    end
 
-        else
-          raise ArgumentError, "wizard called without a block"
-        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
 
-    module ControllerInstanceMethods
-      extend ActiveSupport::Concern
-
-      included do
-        before_filter :setup_wizard
+    def next_step(name=nil)
+      if name.nil?
+        # getter
+        ht_wizard.next_step
+      else
+        # setter
+        step = ht_wizard.find_step(name)
+        # explicitly set steps should not be skipped
+        step.skipped = false
+        ht_wizard.current_step.next_step = step
       end
+    end
 
-      private
+    def skip_this_step
+      ht_wizard.skip_step(ht_wizard.current_step)
+    end
 
-      attr_reader :ht_wizard
+    module ClassMethods
+      attr_reader :wizard_def
 
-      def setup_wizard
-        wizard_def = self.class.instance_variable_get("@wizard_def")
-        @ht_wizard = wizard_def.get_wizard(self)
+      def wizard(&block)
+        if block_given?
+          include HatTrick::DSL::ControllerInstanceMethods
+          include HatTrick::ControllerHooks
 
-        if params.has_key?('_ht_meta')
-          step_name = params['_ht_meta']['step']
-          @ht_wizard.current_step = step_name if step_name
-        end
-      end
-    end
+          @wizard_def = HatTrick::WizardDefinition.new
 
-    class WizardContext
-      attr_reader :wizard_def
-      attr_accessor :wizard
+          yield
 
-      delegate :model, :previously_visited_step, :to => :wizard
+        else
+          raise ArgumentError, "wizard called without a block"
+        end
+      end
 
-      def initialize(wizard_def)
-        @wizard_def = wizard_def
+      def configure(&block)
+        raise "Must pass a block to configure" unless block_given?
+        @config_callback = block
       end
 
       def step(name, args={}, &block)
+        raise "step must be called from within a wizard block" unless wizard_def
         wizard_def.add_step(name, args)
         instance_eval &block if block_given?
       end
 
-      def next_step(name=nil)
-        if name.nil?
-          wizard.next_step
-        else
-          raise "next_step should only be called from an after block" if wizard.nil?
-          step = wizard.find_step(name)
-          wizard.current_step.next_step = step
-        end
-      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
@@ -77,47 +76,72 @@ module HatTrick
         new_step.fieldset = repeated_step.fieldset
         # but use the current step's name
         new_step.name = wizard_def.last_step.name
-        if wizard
-          # TODO: Might turn all these into run-time methods; which would get
-          # rid of this wizard / wizard_def distinction
-        else
-          # replace the step we're in the middle of defining w/ new_step
-          wizard_def.replace_step(wizard_def.last_step, new_step)
-        end
+        # 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
-        if wizard
-          wizard.skip_step(wizard.current_step)
-        else
-          # skip_this_step in wizard definition context means the step
-          # can be explicitly jumped to, but won't be in the normal flow
-          wizard_def.last_step.skipped = true
-        end
+        # 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
+        raise "skip_this_step must be called from within a wizard block" unless wizard_def
+        wizard_def.last_step.skipped = true
       end
 
       def button_to(name, options=nil)
-        if wizard
-          raise "button_to not yet supported in before/after blocks"
-        end
+        raise "button_to must be called from within a wizard block" unless wizard_def
         label = options[:label] if options
         label ||= name.to_s.humanize
+
+        id = options[:id] if options
+
         step = wizard_def.last_step
-        step.buttons = step.buttons.merge(name => label)
+        button = { :label => label }
+        button[:id] = id unless id.nil?
+        step.buttons = step.buttons.merge(name => button)
       end
 
       def before(&block)
+        raise "before must be called from within a wizard block" unless wizard_def
         wizard_def.last_step.before_callback = block
       end
 
       def after(&block)
+        raise "after must be called from within a wizard block" unless wizard_def
         wizard_def.last_step.after_callback = block
       end
 
       def include_data(key, &block)
+        raise "include_data must be called from within a wizard block" unless wizard_def
         wizard_def.last_step.include_data = { key.to_sym => block }
       end
+
+      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) }
+        end
+      end
+    end
+
+    module ControllerInstanceMethods
+      extend ActiveSupport::Concern
+
+      included do
+        before_filter :setup_wizard
+      end
+
+      private
+
+      def setup_wizard
+        wizard_def = self.class.instance_variable_get("@wizard_def")
+        @ht_wizard = wizard_def.get_wizard(self)
+
+        if params.has_key?('_ht_meta')
+          step_name = params['_ht_meta']['step']
+          @ht_wizard.current_step = step_name if step_name
+        end
+      end
     end
   end
 end
-

data/lib/hat_trick/{rails_engine.rb → engine.rb}

@@ -1,7 +1,7 @@
 require 'hat_trick/form_helper'
 
 module HatTrick
-  class RailsEngine < ::Rails::Engine
+  class Engine < ::Rails::Engine
     # just defining this causes Rails to look for assets inside this gem
 
     initializer 'hat-trick.form_helpers' do

data/lib/hat_trick/form_helper.rb

@@ -7,10 +7,6 @@ module HatTrick
       wizard = controller.send(:ht_wizard)
       wizard.start unless wizard.started?
 
-      # Do we still need these 2 lines?
-      wizard.model = record
-      controller.gon.form_model = record
-
       options[:url] = wizard.current_form_url
       options[:method] = wizard.current_form_method.to_sym
 

data/lib/hat_trick/model_methods.rb

@@ -1,24 +1,46 @@
 module HatTrick
   module ModelMethods
     extend ActiveSupport::Concern
-    mattr_accessor :current_validation_group
+    mattr_accessor :validation_groups
+
+    attr_accessor :_dummy # so the dummy field will have something to set
 
     included do
-      alias_method_chain :save, :hat_trick
+      alias_method_chain :perform_validations, :hat_trick if instance_methods.include?(:perform_validations)
+      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)
-      self.current_validation_group ||= {}
-      current_validation_group[klass.to_s.underscore] = validation_group_name
+      self.validation_groups ||= {}
+      validation_groups[klass.to_s.underscore] = validation_group_name
     end
 
     def self.current_validation_group_for(klass)
-      current_validation_group[klass.to_s.underscore]
+      return nil unless validation_groups
+      validation_groups[klass.to_s.underscore]
+    end
+
+    def perform_validations_with_hat_trick(*args, &block)
+      enable_current_validation_group
+      perform_validations_without_hat_trick(*args, &block)
+    end
+
+    def as_json_with_model_name(*args, &block)
+      json = as_json_without_model_name(*args, &block)
+      json.merge! :__name__ => self.class.to_s.underscore if json.respond_to?(:merge!)
+    end
+
+    private
+
+    # don't call this method 'current_validation_group', it conflicts with
+    # the gem
+    def current_step_validation_group
+      HatTrick::ModelMethods.current_validation_group_for(self.class)
     end
 
-    def save_with_hat_trick(*args)
-      enable_validation_group HatTrick::ModelMethods.current_validation_group_for(self.class)
-      save_without_hat_trick(*args)
+    def enable_current_validation_group
+      validation_group = current_step_validation_group
+      enable_validation_group validation_group if validation_group
     end
   end
 end

data/lib/hat_trick/step_definition.rb

@@ -17,7 +17,7 @@ module HatTrick
     end
 
     def initialize_copy(source)
-      @callbacks = source.callbacks.dup
+      @callbacks = {}
       @buttons = source.buttons.dup
       @skipped = false
       @repeat_of = source
@@ -74,27 +74,27 @@ module HatTrick
       @include_data_key = hash.keys.first
     end
 
-    def run_before_callback(context, wizard_dsl, model)
-      run_callback(:before, context, wizard_dsl, model)
+    def run_before_callback(context, model)
+      run_callback(:before, context, model)
     end
 
-    def run_include_data_callback(context, wizard_dsl, model)
-      run_callback(:include_data, context, wizard_dsl, model)
+    def run_include_data_callback(context, model)
+      run_callback(:include_data, context, model)
     end
 
-    def run_after_callback(context, wizard_dsl, model)
-      run_callback(:after, context, wizard_dsl, model)
+    def run_after_callback(context, model)
+      run_callback(:after, context, model)
     end
 
     protected
 
-    def run_callback(type, context, *args)
+    def run_callback(type, context, model)
       callback = callbacks[type.to_sym]
       if callback && callback.is_a?(Proc)
-        if callback.arity > 1
-          context.instance_exec args[0], args[1], &callback
-        elsif callback.arity == 1
-          context.instance_exec args[0], &callback
+        if callback.arity > 0
+          unless model.is_a?(ActiveModel::Errors)
+            context.instance_exec model, &callback
+          end
         else
           context.instance_eval &callback
         end

data/lib/hat_trick/version.rb

@@ -1,3 +1,3 @@
 module HatTrick
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/hat_trick/wizard.rb

@@ -1,17 +1,16 @@
 require 'hat_trick/controller_hooks'
 require 'hat_trick/wizard_steps'
+require 'hat_trick/dsl'
 
 module HatTrick
   class Wizard
     include WizardSteps
 
     attr_accessor :controller, :model
-    attr_reader :current_step, :wizard_def, :wizard_dsl_context, :steps
+    attr_reader :current_step, :wizard_def, :steps
 
     def initialize(wizard_def)
       @wizard_def = wizard_def
-      @wizard_dsl_context = DSL::WizardContext.new(@wizard_def)
-      @wizard_dsl_context.wizard = self
       @steps = @wizard_def.steps.map { |s| HatTrick::Step.new(s, self) }
     end
 
@@ -19,6 +18,13 @@ module HatTrick
       @controller = new_controller
     end
 
+    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)
@@ -27,7 +33,11 @@ module HatTrick
     end
 
     def session
-      controller.session unless controller.nil?
+      if controller.nil?
+        fake_session
+      else
+        controller.session
+      end
     end
 
     def model_created?
@@ -43,11 +53,13 @@ module HatTrick
     end
 
     def create_url
+      wizard_def.configured_create_url or
       controller.url_for(:controller => controller.controller_name,
                          :action => 'create', :only_path => true)
     end
 
     def update_url
+      wizard_def.configured_update_url or
       if model_created?
         controller.url_for(:controller => controller.controller_name,
                            :action => 'update', :id => model,
@@ -80,28 +92,16 @@ module HatTrick
 
     def start
       session["hat-trick.steps_visited"] = []
-      self.current_step = first_step
+      self.current_step ||= first_step
       run_before_callback
     end
 
-    def finish
-      # Do something here
-      # Such as: Force the wizard to display the "done" page
-      Rails.logger.info "WIZARD FINISHED!"
-    end
-
     def run_before_callback(step=current_step)
-      step.run_before_callback(controller, wizard_dsl_context, model)
+      step.run_before_callback(controller, model)
     end
 
     def run_after_callback(step=current_step)
-      step.run_after_callback(controller, wizard_dsl_context, model)
-    end
-
-    def advance_step_with_debugger
-      require 'ruby-debug'
-      debugger
-      advance_step
+      step.run_after_callback(controller, model)
     end
 
     def advance_step(next_step_name=nil)
@@ -114,7 +114,7 @@ module HatTrick
 
       # finish if we're on the last step
       if current_step == last_step && !requested_next_step
-        finish
+        raise "Tried to advance beyond the last step of the wizard"
       else # we're not on the last step
         if requested_next_step
           Rails.logger.info "Force advancing to step: #{requested_next_step}"
@@ -135,10 +135,20 @@ module HatTrick
     end
 
     def include_data
-      return {} unless model
-      inc_data = current_step.run_include_data_callback(controller, wizard_dsl_context, model)
-      data_key = current_step.include_data_key
-      { data_key.to_s.camelize(:lower) => camelize_hash_keys(inc_data) }
+      return {} if model.nil?
+      inc_data = {}
+      include_data_steps = steps_before(current_step) << 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
     end
 
     def alias_action_methods
@@ -155,6 +165,10 @@ module HatTrick
 
     private
 
+    def fake_session
+      @fake_session ||= {}
+    end
+
     def find_next_step
       find_step(current_step.next_step) or find_step_after(current_step)
     end
@@ -165,10 +179,13 @@ module HatTrick
     end
 
     def camelize_hash_keys(_hash)
-      return nil if _hash.nil?
       hash = {}
-      _hash.each do |k,v|
-        hash[k.to_s.camelize(:lower)] = v
+      if _hash.respond_to?(:each)
+        _hash.each do |k,v|
+          hash[k.to_s.camelize(:lower)] = v
+        end
+      else
+        hash = _hash
       end
       hash
     end

data/lib/hat_trick/wizard_definition.rb

@@ -6,6 +6,8 @@ module HatTrick
   class WizardDefinition
     include WizardSteps
 
+    attr_accessor :configured_create_url, :configured_update_url
+
     def initialize
       @steps = []
     end

data/lib/hat_trick/wizard_steps.rb

@@ -26,7 +26,9 @@ module HatTrick
     def steps_after(_step)
       step = find_step(_step)
       return [] unless step
-      after_index = steps.index(step) + 1
+      step_index = steps.index(step)
+      max_index = steps.count - 1
+      after_index = step_index < max_index ? step_index + 1 : step_index
       steps[after_index .. -1]
     end
 
@@ -37,7 +39,8 @@ module HatTrick
     def steps_before(_step)
       step = find_step(_step)
       return [] unless step
-      before_index = steps.index(step) - 1
+      step_index = steps.index(step)
+      before_index = step_index > 0 ? step_index - 1 : step_index
       steps[0 .. before_index]
     end
 

data/spec/lib/hat_trick/dsl_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+# will automatically get HatTrick::DSL included
+class FakeController < ActionController::Base; end
+
+describe HatTrick::DSL do
+  let(:controller_class) { FakeController }
+
+  # 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
+          wizard do
+            step :foo
+          end
+        end
+      end
+    end
+  end
+end