edk-wizardly 0.1.8.9

data/lib/wizardly/wizard/configuration.rb

@@ -0,0 +1,194 @@
+require 'wizardly/wizard/utils'
+require 'wizardly/wizard/dsl'
+require 'wizardly/wizard/button'
+require 'wizardly/wizard/page'
+require 'wizardly/wizard/configuration/methods'
+
+module Wizardly
+  module Wizard
+    class Configuration
+      include TextHelpers
+      attr_reader :pages, :completed_redirect, :canceled_redirect, :controller_path, :controller_class_name, :controller_name, :page_order
+      
+      #enum_attr :persistance, %w(sandbox session database)
+
+      def initialize(controller, opts) #completed_redirect = nil, canceled_redirect = nil)
+        @controller_class_name = controller.to_s.camelcase
+        @controller_class_name += 'Controller' unless @controller_class_name =~ /Controller$/
+        @controller_path = @controller_class_name.sub(/Controller$/,'').underscore
+        @controller_name = @controller_class_name.demodulize.sub(/Controller$/,'').underscore
+        @completed_redirect = opts[:completed] || opts[:when_completed] || opts[:redirect] #format_redirect(completed_redirect)
+        @canceled_redirect = opts[:canceled] || opts[:when_canceled] || opts[:redirect]
+        @include_skip_button = opts[:skip] || opts[:allow_skip] || opts[:allow_skipping] || false
+        @include_cancel_button = opts.key?(:cancel) ? opts[:cancel] : true
+        @guard_entry = opts.key?(:guard) ? opts[:guard] : true
+        @password_fields = opts[:mask_fields] || opts[:mask_passwords] || [:password, :password_confirmation]
+        @persist_model = opts[:persist_model] || :per_page
+        @form_data = opts[:form_data] || :session
+        raise(ArgumentError, ":persist_model option must be one of :once or :per_page", caller) unless [:once, :per_page].include?(@persist_model)
+        raise(ArgumentError, ":form_data option must be one of :sandbox or :session", caller) unless [:sandbox, :session].include?(@form_data)
+        @page_order = []
+        @pages = {}
+        @buttons = nil
+        @default_buttons = Hash[*[:next, :back, :cancel, :finish, :skip].collect {|default| [default, Button.new(default)] }.flatten]
+      end
+
+      def guard?; @guard_entry; end
+      def persist_model_per_page?; @persist_model == :per_page; end
+      def form_data_keep_in_session?; @form_data == :session; end
+      def model; @wizard_model_sym; end
+      def model_instance_variable; "@#{@wizard_model_sym.to_s}"; end
+      def model_class_name; @wizard_model_class_name; end
+      def model_const; @wizard_model_const; end
+
+      def first_page?(name); @page_order.first == name; end
+      def last_page?(name); @page_order.last == name; end
+      def next_page(name)
+        index = @page_order.index(name)
+        index += 1 unless self.last_page?(name)
+        @page_order[index]
+      end
+      def previous_page(name)
+        index = @page_order.index(name)
+        index -= 1 unless self.first_page?(name)
+        @page_order[index]
+      end
+      def button_for_function(name); @default_buttons[name]; end
+      def buttons
+        return @buttons if @buttons
+        # reduce buttons
+        @buttons = Hash[*@default_buttons.collect{|k,v|[v.id, v]}.flatten]
+      end
+    
+      def self.create(controller_name, model_name, opts={}, &block)
+        # controller_name = controller_name.to_s.underscore.sub(/_controller$/, '').to_sym
+        model_name = model_name.to_s.underscore.to_sym
+        config = Wizardly::Wizard::Configuration.new(controller_name, opts)
+        config.inspect_model!(model_name)
+        Wizardly::Wizard::DSL.new(config).instance_eval(&block) if block_given?
+        config
+      end
+
+    
+      def inspect_model!(model)
+        # first examine the model symbol, transform and see if the constant
+        # exists
+        begin
+          @wizard_model_sym = model.to_sym
+          @wizard_model_class_name = model.to_s.camelize
+          @wizard_model_const = @wizard_model_class_name.constantize
+        rescue Exception=>e
+          raise ModelNotFoundError, "Cannot convert :#{@wizard_model_sym} to model constant for #{@wizard_model_class_name}: " + e.message, caller
+        end
+
+        begin
+          @page_order = @wizard_model_const.validation_group_order 
+        rescue Exception => e
+          raise ValidationGroupError, "Unable to read validation groups from #{@wizard_model_class_name}: " + e.message, caller
+        end
+        raise(ValidationGroupError, "No validation groups defined for model #{@wizard_model_class_name}", caller) unless (@page_order && !@page_order.empty?)
+
+        begin
+          groups = @wizard_model_const.validation_groups
+          enum_attrs = @wizard_model_const.respond_to?(:enumerated_attributes) ? @wizard_model_const.enumerated_attributes.collect {|k,v| k } : []
+          model_inst = @wizard_model_const.new
+          last_index = @page_order.size-1
+          @page_order.each_with_index do |p, index|
+            fields = groups[p].map do |f|
+              column = model_inst.column_for_attribute(f)
+              type = case
+              when enum_attrs.include?(f) then :enum
+              when (@password_fields && @password_fields.include?(f)) then :password
+              else
+                column ? column.type : :string
+              end
+              PageField.new(f, type)
+            end
+            page = Page.new(self, p, fields)
+
+            # default button settings based on order, can be altered by
+            # set_page(@id).buttons_to []
+            buttons = []
+            buttons << @default_buttons[:next] unless index >= last_index
+            buttons << @default_buttons[:finish] if index == last_index
+            buttons << @default_buttons[:back] unless index == 0
+            buttons << @default_buttons[:skip] if (@include_skip_button && index != last_index)
+            buttons << @default_buttons[:cancel] if (@include_cancel_button)
+            page.buttons = buttons
+            @pages[page.id] = page
+          end
+        rescue Exception => e
+          raise ValidationGroupError, "Failed to configure wizard from #{@wizard_model_class_name} validation groups: " + e.message, caller
+        end
+      end
+
+      public
+      # internal DSL method handlers
+      def _when_completed_redirect_to(redir); @completed_redirect = redir; end
+      def _when_canceled_redirect_to(redir); @canceled_redirect = redir; end
+      def _change_button(name)
+        raise(WizardConfigurationError, "Button :#{name} in _change_button() call does not exist", caller) unless self.buttons.key?(name)
+        _buttons = self.buttons
+        @buttons = nil # clear the buttons for regeneration after change in next line
+        _buttons[name]
+      end
+      def _create_button(name, opts)
+        id = opts[:id] || button_name_to_symbol(name)
+        raise(WizardConfigurationError, "Button '#{name}' with id :#{id} cannot be created. The ID already exists.", caller) if self.buttons.key?(id)
+        @buttons=nil
+        @default_buttons[id] = UserDefinedButton.new(id, name)
+      end
+      def _set_page(name); @pages[name]; end
+      def _mask_passwords(passwords)
+        case passwords
+        when String
+          passwords = [passwords.to_sym]
+        when Symbol
+          passwords = [passwords]
+        when Array
+        else
+          raise(WizardlyConfigurationError, "mask_passwords method only accepts string, symbol or array of password fields")
+        end
+        @password_fields.push(*passwords).uniq!
+      end
+      
+      def print_config
+        io = StringIO.new
+        class_name = controller_name.to_s.camelize
+        class_name += 'Controller' unless class_name =~ /Controller$/
+        io.puts "#{class_name} wizard configuration"
+        io.puts
+        io.puts "model: #{model_class_name}"
+        io.puts "instance: @#{model}"
+        io.puts
+        io.puts "pages:"
+        self.page_order.each do |pid|
+          page = pages[pid]
+          # io.puts "  #{index+1}. '#{page.title}' page (:#{page.id}) has"
+          io.puts "  '#{page.title}' page (:#{page.id}) has"
+          io.puts "    --fields: #{page.fields.inject([]){|a, f| a << '"'+f.name.to_s.titleize+'" [:'+f.column_type.to_s+']'}.join(', ')}"
+          io.puts "    --buttons: #{page.buttons.inject([]){|a, b| a << b.name.to_s }.join(', ')}"
+        end
+        io.puts
+        io.puts "redirects:"
+        io.puts "  when completed: #{completed_redirect ? completed_redirect.inspect : 'redirects to initial referer by default (specify :completed=>url to override)'}"
+        io.puts "  when canceled: #{canceled_redirect ? canceled_redirect.inspect : 'redirects to initial referer by default (specify :canceled=>url to override)'}"
+        io.puts   
+        io.puts "buttons:"
+        self.buttons.each do |k, b|
+          bs = StringIO.new
+          bs << "  #{b.name} (:#{b.id}) "
+          if (b.user_defined?)
+            bs << "-- user defined button and function"
+          else
+            dk = @default_buttons.index(b)
+            bs << "-- used for internal <#{dk}> functionality"
+          end
+          io.puts bs.string
+        end
+        io.puts 
+        io.string      
+      end    
+    end
+  end    
+end

data/lib/wizardly/wizard/dsl.rb

@@ -0,0 +1,27 @@
+module Wizardly
+  module Wizard
+    class DSL
+    
+      def initialize(config)
+        @config = config
+      end
+    
+      # DSL methods
+      def when_completed_redirect_to(redir); @config._when_completed_redirect_to(redir); end
+      def when_canceled_redirect_to(redir); @config._when_canceled_redirect_to(redir); end
+      def change_button(name)
+        @config._change_button(name)
+      end
+      def create_button(name, opts)
+        @config._create_button(name, opts)
+      end
+      def set_page(name); 
+        @config._set_page(name)
+      end
+      def mask_passwords(passwords)
+        @config._mask_passwords(passwords)
+      end
+      alias_method :mask_password, :mask_passwords    
+    end    
+  end
+end

data/lib/wizardly/wizard/page.rb

@@ -0,0 +1,62 @@
+require 'wizardly/wizard/text_helpers'
+
+module Wizardly
+  module Wizard
+    class Page
+      include TextHelpers
+      
+      attr_reader :id, :title, :description
+      attr_accessor :buttons, :fields
+
+      def initialize(config, id, fields)
+        @buttons = []
+        @title = symbol_to_button_name(id)
+        @id = id
+        @description = ''
+        @fields = fields 
+        @config = config
+      end
+
+      def name; id.to_s; end
+
+      def buttons_to(*args)
+        buttons = @config.buttons
+        @buttons = args.map do |button_id|
+          raise(WizardConfigurationError, ":#{button_id} not defined as a button id in :button_to() call", caller) unless buttons.key?(button_id)
+          buttons[button_id]
+        end
+      end
+      def title_to(name)
+        @title = name.strip.squeeze(' ')
+      end
+      def description_to(name)
+        @description = name.strip.squeeze(' ')
+      end
+    end
+
+    class PageField
+      attr_reader :name, :column_type
+
+      def initialize(name, type)
+        @name = name
+        @column_type = type.to_sym
+        @field_type = nil
+      end
+
+      def field_type
+        @field_type ||= case @column_type
+        when :string                      then :text_field
+        when :password                    then :password_field
+        when :enum                        then :enum_select
+        when :text                        then :text_area
+        when :boolean                     then :check_box
+        when :integer, :float, :decimal   then :text_field
+        when :datetime, :timestamp, :time then :datetime_select
+        when :date                        then :date_select
+        else
+          :text_field
+        end
+      end
+    end    
+  end
+end

data/lib/wizardly/wizard/text_helpers.rb

@@ -0,0 +1,16 @@
+module Wizardly
+  module Wizard
+    module TextHelpers
+      private
+      def underscore_button_name(name)
+        name.to_s.strip.squeeze(' ').gsub(/ /, '_').downcase
+      end
+      def button_name_to_symbol(str)
+        underscore_button_name(str).to_sym
+      end
+      def symbol_to_button_name(sym)
+        sym.to_s.gsub(/_/, ' ').squeeze(' ').titleize
+      end
+    end
+  end
+end

data/lib/wizardly/wizard/utils.rb

@@ -0,0 +1,11 @@
+module Wizardly
+  module Wizard
+    module Utils
+      def self.formatted_redirect(r)
+        return(nil) unless r
+        r.is_a?(Hash)? r : "'#{r}'"
+      end
+    end
+  end
+end
+

data/lib/wizardly/wizard.rb

@@ -0,0 +1,16 @@
+require 'wizardly/wizard/configuration'
+
+module Wizardly
+  class WizardlyError < StandardError; end
+  class ModelNotFoundError < WizardlyError; end
+  class ValidationGroupError < WizardlyError; end
+  class CallbackError < WizardlyError; end
+  class MissingCallbackError < WizardlyError; end
+  class WizardConfigurationError < WizardlyError; end
+  class RedirectNotDefinedError < WizardlyError; end
+  
+  class WizardlyGeneratorError < WizardlyError; end
+  class WizardlyScaffoldError < WizardlyGeneratorError; end
+  class WizardlyControllerGeneratorError < WizardlyGeneratorError; end    
+  
+end

data/lib/wizardly.rb

@@ -0,0 +1,31 @@
+require 'validation_group'
+require 'wizardly/action_controller'
+
+module Wizardly
+  module ActionController
+    module MacroMethods
+      def wizard_for_model(model, opts={}, &block)
+        include Wizardly::ActionController
+        #check for validation group gem
+        configure_wizard_for_model(model, opts, &block)
+      end
+      alias_method :act_wizardly_for, :wizard_for_model
+    end
+  end
+end
+
+begin
+  ActiveRecord::Base.class_eval do
+    class << self
+      alias_method :wizardly_page, :validation_group
+    end
+  end
+rescue
+end
+
+ActionController::Base.send(:extend, Wizardly::ActionController::MacroMethods)
+
+
+
+
+

data/rails_generators/wizardly_app/USAGE

@@ -0,0 +1,6 @@
+Prepares a rails application to use wizardly gem
+
+Moves the wizardly.rake file in to lib/tasks directory
+
+
+

data/rails_generators/wizardly_app/templates/wizardly.rake

@@ -0,0 +1,37 @@
+
+namespace :wizardly do
+  desc "Display wizard configuration details"
+  task :config => :environment do
+    name = ENV['name']
+    return print_usage unless name
+    begin
+      name = name.strip.camelize
+      name += 'Controller' unless name.match('Controller$')
+      controller = name.constantize
+      begin
+        c = controller.wizard_config
+        begin
+          puts
+          puts c.print_config
+        rescue Exception=>e
+          puts "Problem printing configuration."
+          puts "#{e.class.name} -- #{e.message}"
+          puts
+        end
+      rescue Exception=>e
+        puts "{#{name}} is not a 'wizardly' controller.\nMake sure 'wizard_for_model' is defined in the controller class." 
+        puts "#{e.class.name} -- #{e.message}"
+        puts
+      end
+    rescue Exception=>e
+      puts "{#{name}} does not reference a controller class."
+      puts "#{e.class.name} -- #{e.message}"
+      puts
+    end
+  end
+  
+  def print_usage
+    puts "Usage: rake wizardly:config name={controller_name}"
+    puts
+  end
+end

data/rails_generators/wizardly_app/wizardly_app_generator.rb

@@ -0,0 +1,41 @@
+#require 'wizardly'
+
+class WizardlyAppGenerator < Rails::Generator::Base
+  
+  def initialize(runtime_args, runtime_options = {})
+    super
+  end
+  
+  def manifest
+    record do |m|
+      m.directory "lib/tasks"
+      
+      m.file "wizardly.rake", "lib/tasks/wizardly.rake"
+      
+    end
+  end
+  
+  def controller_class_name
+    "#{controller_name.camelize}Controller"
+  end
+  def model_class_name
+    "#{model_name.camelize}"
+  end
+  def action_methods
+    @wizard_config.print_page_action_methods
+  end
+  def callback_methods
+    @wizard_config.print_callbacks
+  end
+  def helper_methods
+    @wizard_config.print_helpers
+  end
+  
+  protected
+  # Override with your own usage banner.
+  def banner
+    "Usage: #{$0} wizardly_app"
+  end
+  
+  
+end

data/rails_generators/wizardly_controller/USAGE

@@ -0,0 +1,3 @@
+Generates a wizard controller with all the code displayed
+
+

data/rails_generators/wizardly_controller/templates/controller.rb.erb

@@ -0,0 +1,34 @@
+#
+# <%= controller_class_name %> class generated by wizardly_controller
+#
+
+class <%= controller_class_name %> < ApplicationController
+  before_filter :guard_entry
+
+  <%= action_methods %>
+
+  <%= callback_methods %>
+
+  <%= helper_methods %>
+
+  <%= callback_macro_methods %>
+
+  public
+  def wizard_config; self.class.wizard_config; end
+  hide_action :wizard_config
+  
+  private
+
+  def self.wizard_config; @wizard_config; end
+  @wizard_config = Wizardly::Wizard::Configuration.create(:<%=controller_name %>, :<%=model_name %>, :allow_skip=>true) do
+    <%= "when_completed_redirect_to #{Wizardly::Wizard::Utils.formatted_redirect(completed_redirect)}" if completed_redirect %>
+    <%= "when_canceled_redirect_to #{Wizardly::Wizard::Utils.formatted_redirect(canceled_redirect)}" if canceled_redirect  %>
+    
+    # other things you can configure
+    # change_button(:next).to('Next One')
+    # change_button(:back).to('Previous')
+    # create_button('Help')
+    # set_page(:init).buttons_to :next_one, :previous, :cancel, :help #this removes skip
+  end
+
+end

data/rails_generators/wizardly_controller/templates/helper.rb.erb

@@ -0,0 +1,14 @@
+module <%=controller_name.camelize %>Helper
+  
+  def wizardly_submit
+    @@wizardly_submit ||= {}
+    unless @@wizardly_submit[@step]
+      buttons = @wizard.pages[@step].buttons
+      @@wizardly_submit[@step] = buttons.inject(StringIO.new) do |io, button|
+        io << submit_tag(button.name)
+      end.string
+    end
+    @@wizardly_submit[@step]
+  end
+  
+end

data/rails_generators/wizardly_controller/wizardly_controller_generator.rb

@@ -0,0 +1,57 @@
+require 'wizardly'
+
+class WizardlyControllerGenerator < Rails::Generator::Base
+  attr_reader :controller_name, :model_name, :completed_redirect, :canceled_redirect
+  
+  def initialize(runtime_args, runtime_options = {})
+    super
+    @controller_name = @args[0].sub(/^:/,'')
+    @model_name = @args[1].sub(/^:/, '').underscore
+    @completed_redirect = @args[2]
+    @canceled_redirect = @args[3]
+    opts = {}
+    opts[:completed] = @completed_redirect if @completed_redirect
+    opts[:canceled] = @canceled_redirect if @canceled_redirect
+    
+    @wizard_config = Wizardly::Wizard::Configuration.new(@controller_name, opts)
+    @wizard_config.inspect_model!(@model_name.to_sym)
+  end
+  
+  def manifest
+    record do |m|
+      m.directory "app/controllers"
+      
+      m.template "controller.rb.erb", "app/controllers/#{controller_name}_controller.rb"
+      
+      m.template "helper.rb.erb", "app/helpers/#{controller_name}_helper.rb"
+      
+    end
+  end
+  
+  def controller_class_name
+    "#{controller_name.camelize}Controller"
+  end
+  def model_class_name
+    "#{model_name.camelize}"
+  end
+  def action_methods
+    @wizard_config.print_page_action_methods
+  end
+  def callback_methods
+    @wizard_config.print_callbacks
+  end
+  def helper_methods
+    @wizard_config.print_helpers
+  end
+  def callback_macro_methods
+    @wizard_config.print_callback_macros
+  end
+  
+  protected
+  # Override with your own usage banner.
+  def banner
+    "Usage: #{$0} wizardly_controller controller_name model_name [completed_redirect canceled_redirect]"
+  end
+  
+  
+end

data/rails_generators/wizardly_scaffold/USAGE

@@ -0,0 +1,4 @@
+Generates a wizard scaffold from a wizard controller using wizard_for_model (or wizard_for)
+
+
+

data/rails_generators/wizardly_scaffold/templates/form.html.erb

@@ -0,0 +1,23 @@
+<h1><%= page.title %></h1>
+
+<%= "<p>#{page.description}<p>" if !page.description.blank? %>
+<%%= "<p style=\"color: green\">#{flash[:notice]}<p>" if flash[:notice] %>
+
+<%% form_for :<%= model_name %>, :url=>{:action=>:<%= page.name %>}  do |f| %>
+  <%%= f.error_messages %>
+
+<% for field in page.fields -%>
+  <% first_field_id ||= "#{model_name}_#{field.name}" %>
+  <p>
+    <%%= f.label :<%= field.name %> %><br />
+    <%%= f.<%= field.field_type %> :<%= field.name %> %>
+  </p>
+<% end -%>
+  <p>
+    <%%= <%= submit_tag %> %>
+  </p>
+<%% end %>
+
+<script type='text/javascript'>
+  document.getElementById('<%=first_field_id %>').focus()
+</script>

data/rails_generators/wizardly_scaffold/templates/form.html.haml.erb

@@ -0,0 +1,22 @@
+%h1 <%= page.title %>
+
+<% unless page.description.blank? %>
+  %p <%= page.description %>
+<% end %>
+- if flash[:notice]
+  %p{:style=>'color: green'}= flash[:notice]
+
+- form_for :<%= model_name %>, :url=>{:action=>:<%= page.name %>} do |f|
+  = f.error_messages
+  
+<% for field in page.fields %>
+  <% first_field_id ||= "#{model_name}_#{field.name}" %>
+  %p
+    = f.label :<%= field.name %>
+    %br
+    = f.<%= field.field_type %> :<%= field.name %>
+<% end %>
+  %p= <%= submit_tag %>
+
+%script{:type=>'text/javascript'} 
+  document.getElementById('<%=first_field_id %>').focus()

data/rails_generators/wizardly_scaffold/templates/helper.rb.erb

@@ -0,0 +1,30 @@
+module <%=controller_name.camelize %>Helper
+  
+  def wizardly_submit
+    @@wizardly_submit ||= {}
+    step_id = "#{controller_name}_#{@step}".to_sym
+    unless @@wizardly_submit[step_id]
+      buttons = @wizard.pages[@step].buttons
+      @@wizardly_submit[step_id] = buttons.inject(StringIO.new) do |io, button|
+        io << submit_tag(button.name, :name=>button.id.to_s)
+      end.string
+    end
+    @@wizardly_submit[step_id]
+  end
+  
+  def wizardly_image_submit(asset_dir = nil, opts = {})
+    @@wizardly_image_submit ||={}
+    step_id = "#{controller_name}_#{@step}".to_sym
+    unless @@wizardly_image_submit[step_id]
+      asset_dir = asset_dir ? "#{asset_dir}/".squeeze("/").sub(/^\//,'') : "wizardly/"
+      buttons = @wizard.pages[@step].buttons
+      @@wizardly_image_submit[step_id] = buttons.inject(StringIO.new) do |io, button|
+        opts[:value] = button.name
+        opts[:name] = button.id.to_s
+        io << image_submit_tag("#{asset_dir}#{button.id}.png", opts)
+      end.string
+    end
+    @@wizardly_image_submit[step_id]
+  end
+  
+end

data/rails_generators/wizardly_scaffold/templates/layout.html.erb

@@ -0,0 +1,15 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
+  <title><%= controller_class_name %>: <%%= controller.action_name %></title>
+  <%%= stylesheet_link_tag 'scaffold' %>
+</head>
+<body>
+
+<%%= yield %>
+
+</body>
+</html>