wizardz 1.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,22 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+nbproject/**/*
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 David Henry
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,47 @@
+= wizardz
+
+Multi-Step Creation Wizard
+
+Design to provide a framework for creating multi-step wizard which can have multiple
+models and user-selectable steps ordering based on user input within earlier steps.
+
+The Gem is provides a Wizardz::Wizard class which is exposed to the Controller and
+manages the various steps within the creation process and a Wizardz::Page class
+with represents the individendual pages within the Wizardz.  Both class are designed
+to be inherited from within the final implementation and expose the following methods:
+
+Wizardz::Wizard
+---------------
+STATES      => Constant which contains the HASH of Page Identifier and Page Class pairs
+def create  => Combines the data for the Associated Pages and create the required Objects
+
+Wizardz::Page
+---------------
+IDENTIFER                     => Identifier lookup which should match to the Page
+                                 Identifier from The Wizardz::Wizard:STATES Constant
+PARTIAL                       => Contant name of the Partial to be displayed within
+                                 the view for the page
+def initialize(data)          => Load the required Attributes onto the Page Class
+                                 (set any default values here)
+def get_valid_states(states)  => Update the list page transistion order after page data update
+def get_object                => Return instance of the underlying object (in memory
+                                 only - do not save to table) (only required if
+                                 page_object and valid NOT overwritten
+def page_object               => return object instance (with valid? call if page
+                                 has already been visited)
+def valid?                    => return true/false if object is valid (default
+                                 implementation calls valid? on get_object)
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 David Henry. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "wizardz"
+    gem.summary = %Q{Multi-Step Wizard}
+    gem.description = %Q{Multi-Step wizard that deals with multiple models and changing step options based on previous step input}
+    gem.email = "dave_henry@lyagushka.co.uk"
+    gem.homepage = "http://github.com/dwhenry/wizardz"
+    gem.authors = ["David Henry"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "wizardz #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.1

data/lib/wizardz.rb

@@ -0,0 +1,4 @@
+module Wizardz
+  require 'wizardz/wizard'
+  require 'wizardz/page'
+end

data/lib/wizardz/page.rb

@@ -0,0 +1,75 @@
+  #require File.dirname(__FILE__) + '/page/fund_general'
+
+module Wizardz
+  class Page
+    attr_reader :page_data
+    attr_accessor :wizard_inst
+
+    def self.load_pages(states, page_data, wizard_inst)
+      return_val = {}
+      wizard_inst.classes.each do |class_obj|
+        return_val.merge!(self.subclass_element(class_obj,page_data, states, wizard_inst))
+      end
+      return_val
+    end
+
+    def self.subclass_element(class_obj, page_data,states,wizard_inst)
+      id = class_obj::IDENTIFIER rescue nil
+      return {} if id.nil? or !states.include?(id)
+
+      obj = class_obj.new(page_data[id] || {})
+      obj.wizard_inst = wizard_inst
+      {id => obj}
+    end
+
+
+    def valid?(allow_nil=true)
+      return allow_nil if @page_data.nil?
+      self.get_object.valid?
+    end
+
+    def page_object
+      obj = self.get_object
+      obj.valid? unless @wizard_inst.unprocessed.include?(self.identifier)
+      obj
+    end
+
+    def get_valid_states(states)
+      states
+    end
+
+    def initialize(data={})
+      @page_data = data || {}
+    end
+
+    def partial
+      self.class::PARTIAL rescue "#{self.identifier.to_s}"
+    end
+
+    def page_data
+      @page_data
+    end
+
+    def update(data)
+      @page_data = data[:dataset]
+      self.valid?(false)
+    end
+
+    def transit(direction, states)
+      pos = states.index(self.identifier)
+      raise 'Invalid States list' if pos.nil?
+      pos += 1 if direction == 'next' and pos < states.size - 1
+      pos -= 1 if direction == 'prev' and pos > 0
+      states[pos]
+    end
+
+    protected
+    def identifier
+      self.class::IDENTIFIER rescue nil
+    end
+
+    def get_object
+      WizardObject.new(@page_data)
+    end
+  end
+end

data/lib/wizardz/page/first.rb

@@ -0,0 +1,8 @@
+class Wizardz::Page::First < Wizardz::Page
+  IDENTIFIER = :first_state
+
+  def valid?(allow_nil)
+    true
+  end
+
+end

data/lib/wizardz/wizard.rb

@@ -0,0 +1,87 @@
+require 'wizardz/page'
+require 'wizardz/page/first'
+require 'wizardz/wizard_object'
+
+module Wizardz
+  class Wizard
+    attr_reader :pages
+    attr_reader :state
+    attr_reader :valid_states
+    attr_reader :unprocessed
+
+    STATES={:first_state => Wizardz::Page::First}
+
+    def initialize(fund_data={},state=nil)
+      state = self.states.first if state.nil?
+      state = state.to_sym
+      raise "Invalid State Assignment: #{state}" unless self.states.include?(state)
+      self.load_data(fund_data)
+      @state = state
+    end
+
+    def first_page?
+      self.states.index(@state) <= 0
+    end
+
+    def last_page?
+      self.states.index(@state) >= (self.states.size - 1)
+    end
+
+    def states
+      self.class::STATES.keys
+    end
+
+    def classes
+      self.class::STATES.values
+    end
+
+    def create
+      raise "Create method must be implemented in subclass"
+    end
+
+    def update(data, direction=:next)
+      return true if data.nil?
+      if @pages[@state].update(data)
+        @valid_states = @pages[@state].get_valid_states(@valid_states)
+        @state = @pages[@state].transit(direction, @valid_states)
+      else
+        @state = @pages[@state].transit(direction, @valid_states) if direction.to_sym == :prev
+        return false
+      end
+      return true
+    end
+
+    protected
+    def load_data(fund_data)
+      @valid_states = fund_data[:valid_states] || self.states
+      @unprocessed = fund_data[:unprocessed] || self.states
+      @state ||= self.states.first
+      @pages = Page.load_pages(self.states, fund_data, self)
+    end
+
+    public
+    def save_data
+      results = {}
+      @valid_states.each do |state|
+        results[state] = @pages[state].page_data if @pages[state].respond_to?(:page_data)
+      end
+      results[:states] = @valid_states
+      results[:unprocessed] = @unprocessed.clone
+      results[:unprocessed].delete(@state)
+      results
+    end
+
+    def get_page
+      @pages[@state].page_data
+    end
+
+    def get_page_object
+      @pages[@state].page_object
+    end
+
+    def partial
+      @pages[@state].partial
+    end
+
+  end
+end

data/lib/wizardz/wizard_object.rb

@@ -0,0 +1,11 @@
+class Wizardz::WizardObject
+  attr_reader :page_data
+
+  def initialize(page_data)
+    @page_data = page_data
+  end
+
+  def valid?
+    true
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'wizardz'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

data/spec/wizardz/page_spec.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+
+class TestClass1 < Wizardz::Page
+end
+class TestClass2 < Wizardz::Page
+  IDENTIFIER = :test_class
+end
+class TestClass3 < Wizardz::Page
+  IDENTIFIER = :test_class
+  def valid?(allow_nil=true); end
+end
+
+describe "Page" do
+
+  it "calls new for each subclass" do
+    page_data = {:first_state => {:value => 'test'}}
+    page = Wizardz::Page::First.new
+    Wizardz::Page::First.should_receive(:new).with({:value => 'test'}).and_return(page)
+    Wizardz::Page.load_pages([:first_state], page_data, mock(Wizardz::Wizard, :classes => [Wizardz::Page::First]))
+  end
+
+  it "does not call subclass that do not respond to IDENTIFIER" do
+    wiz_inst =  Wizardz::Wizard.new()
+    TestClass1.should_not_receive(:new).with(anything)
+    Wizardz::Page.load_pages([], {}, wiz_inst)
+  end
+
+  it "does not call subclass that do not exist in states array" do
+    wiz_inst =  Wizardz::Wizard.new()
+    TestClass1.should_not_receive(:new).with(anything)
+    Wizardz::Page::First.should_not_receive(:new).with(anything)
+    Wizardz::Page.load_pages([],{}, wiz_inst)
+  end
+
+  it "does not modify input/output data on get_valid_states call by default" do
+    page = Wizardz::Page::First.new({})
+    page.get_valid_states([:first_state, :second_state]).should == [:first_state, :second_state]
+  end
+
+  it 'does not raise an error if no initialize method is implemented' do
+    lambda {TestClass2.new({})}.should_not raise_error
+  end
+
+  it "returns the page_data object" do
+    page = Wizardz::Page::First.new({:value => 'test'})
+    page.page_data.should == {:value => 'test'} 
+  end
+  context 'update' do
+    it "does not raise an error if no update method implemented" do
+      page = TestClass3.new({})
+      lambda {page.update({:value => 'test 2'})}.should_not raise_error
+    end
+
+    it 'calls the valid? method during the update' do
+      page = Wizardz::Page::First.new({})
+      page.should_receive(:valid?).with(false)
+      page.update({:value => 'test 2'})
+    end
+
+    it 'updates the page data element based on :dataset key from data' do
+      page = Wizardz::Page::First.new({})
+      page.update({:dataset => {:value => 'test 2'}})
+      page.page_data.should == {:value => 'test 2'} 
+    end
+  end
+
+  context 'transit wizard states' do
+    it 'not raise an error if transit if not implemented' do
+      page = Wizardz::Page::First.new({})
+      lambda{page.transit('prev',[:first_state])}.should_not raise_error
+    end
+
+    it 'stay on the same state if next and last state' do
+      page = Wizardz::Page::First.new({})
+      page.transit('next',[:second_state, :first_state]).should == :first_state
+    end
+
+    it 'moves to the next state if next and not last state' do
+      page = Wizardz::Page::First.new({})
+      page.transit('next',[:first_state, :second_state]).should == :second_state
+    end
+
+    it 'stay on the same state if prev and first state' do
+      page = Wizardz::Page::First.new({})
+      page.transit('prev',[:first_state, :second_state]).should == :first_state
+    end
+
+    it 'moves to the next state if prev and not first state' do
+      page = Wizardz::Page::First.new({})
+      page.transit('prev',[:second_state, :first_state]).should == :second_state
+    end
+
+    it 'raise an error if current state if not in options' do
+      page = Wizardz::Page::First.new({})
+      lambda{page.transit('prev',[:second_state])}.should raise_error
+    end
+  end
+
+end

data/spec/wizardz/wizard_spec.rb

@@ -0,0 +1,168 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class TestClassWiz < Wizardz::Page
+  IDENTIFIER = :test_class_wiz
+  def page_object
+    [Wizardz::WizardObject.new('aaa'), Wizardz::WizardObject.new('nnn')]
+  end
+end
+
+class StateRedefWiz < Wizardz::Wizard
+end
+
+describe "Wizard" do
+
+  it "has minimum of 0 parameters on creation" do
+    lambda{Wizardz::Wizard.new()}.should_not raise_error
+  end
+
+  it "has a two optional parameters" do
+    lambda{Wizardz::Wizard.new({}, :first_state)}.should_not raise_error
+  end
+
+  it "2nd paramter must be a member of 'states'" do
+    lambda{Wizardz::Wizard.new({}, :invalid_state)}.should  raise_error
+  end
+
+  it 'initialises valid states from params' do
+    wiz = Wizardz::Wizard.new({:valid_states => [:first_state, :second_state]})
+    wiz.valid_states.should == [:first_state, :second_state]
+  end
+
+  it 'initialises valid states to default value' do
+    StateRedefWiz.class_eval("def states; return [:first_state];end")
+    wiz = StateRedefWiz.new()
+    wiz.valid_states.should == [:first_state]
+  end
+
+  it 'initialises unprocessed states from params' do
+    wiz = Wizardz::Wizard.new({:unprocessed => [:first_state, :second_state]})
+    wiz.unprocessed.should == [:first_state, :second_state]
+  end
+
+  it 'initialises unprocessed states to default value' do
+    StateRedefWiz.class_eval("def states; return [:first_state];end")
+    wiz = Wizardz::Wizard.new()
+    wiz.unprocessed.should == [:first_state]
+  end
+
+  it 'initialises current state from params' do
+    #TODO:: could this be a stub??
+    StateRedefWiz.class_eval('def states; return [:first_state,:second_state]; end')
+    wiz = StateRedefWiz.new({}, :second_state)
+    wiz.state.should == :second_state
+  end
+
+  it 'initialises current_state states to default value' do
+    wiz = StateRedefWiz.new()
+    wiz.state.should == :first_state
+  end
+
+  it 'initialises the fund_page objects from params' do
+    setup_data = {:first_state => {:value => 'test'}}
+    Wizardz::Page.should_receive(:load_pages).with([:first_state, :second_state], setup_data,anything)
+    wiz = StateRedefWiz.new(setup_data)
+  end
+
+  it 'initialises the fund_page to default value' do
+    Wizardz::Page.should_receive(:load_pages).with([:first_state, :second_state],{},anything)
+    wiz = StateRedefWiz.new()
+  end
+
+  it 'returns the data_object to save from default values' do
+    wiz = StateRedefWiz.new()
+    wiz.save_data.should == {:first_state=>{},
+                             :unprocessed=>[:second_state],
+                             :states=>[:first_state, :second_state]}
+  end
+
+  it 'returns the data_object to save from default values' do
+    wiz = StateRedefWiz.new({:first_state => {:value => 'test'}})
+    wiz.save_data.should ==  {:first_state=>{:value=>"test"},
+                              :unprocessed=>[:second_state],
+                              :states=>[:first_state, :second_state]}
+  end
+
+  it 'returns the view partial for the wizard' do
+    wiz = StateRedefWiz.new({:first_state => {:value => 'test'}})
+    wiz.partial.should == 'first_state'
+  end
+
+  it 'returns the current page data' do
+    wiz = StateRedefWiz.new({:first_state => {:value => 'test'}})
+    wiz.pages.inspect
+    wiz.get_page.should == {:value => 'test'}
+  end
+
+  it 'returns the current page data object' do
+    wiz = StateRedefWiz.new({:first_state => {:value => 'test'}})
+    obj = wiz.get_page_object
+    obj.is_a?(Wizardz::WizardObject).should be_true
+    obj.page_data.should == {:value => 'test'} 
+  end
+
+  context 'return an array from page object' do
+    before(:each) do
+      StateRedefWiz.class_eval("def states; return [:first_state,:test_class_wiz];end")
+      StateRedefWiz.class_eval("def classes; return [Wizardz::Page::First,TestClassWiz];end")
+    end
+
+    it 'returns an Array object when page object evals to an array' do
+      wiz = StateRedefWiz.new({:valid_states => [:test_class_wiz],:unprocessed => [:test_class_wiz]}, :test_class_wiz)
+      wiz.get_page_object.is_a?(Array).should be_true
+    end
+
+    it 'does not raise an error with page object an array and unprocessed' do
+      wiz = StateRedefWiz.new({:valid_states => [:test_class_wiz],:unprocessed => [:test_class_wiz]}, :test_class_wiz)
+      lambda{wiz.get_page_object}.should_not raise_error
+    end
+
+    it 'does not raise an error with page object an array and not unprocessed' do
+      wiz = StateRedefWiz.new({:valid_states => [:test_class_wiz],:unprocessed => []}, :test_class_wiz)
+      lambda{wiz.get_page_object}.should_not raise_error
+    end
+  end
+
+  context 'update function' do
+    it 'does not call the update code if a the data passed in is nil' do
+      wiz = StateRedefWiz.new
+      page = wiz.pages[wiz.state]
+      page.should_not_receive(:update)
+      wiz.update(nil)
+    end
+
+    it 'calls the update code if a the data passed in is not nil' do
+      wiz = StateRedefWiz.new
+      page = wiz.pages[wiz.state]
+      page.should_receive(:update).and_return(false)
+      wiz.update(1)
+    end
+
+    it 'calls get_valid_states and transit if update is true' do
+      wiz = StateRedefWiz.new
+      page = wiz.pages[wiz.state]
+      page.stub!(:update).and_return(true)
+      page.should_receive(:get_valid_states).and_return([])
+      page.should_receive(:transit).and_return(:first_state)
+      wiz.update(1)
+    end
+
+    it 'does not calls get_valid_states or transit if update is false' do
+      wiz = StateRedefWiz.new
+      page = wiz.pages[wiz.state]
+      page.stub!(:update).and_return(false)
+      page.should_not_receive(:get_valid_states)
+      page.should_not_receive(:transit)
+      wiz.update(1)
+    end
+  end
+#  it 'return true for the first_look? value (indicates if page should be validated)' do
+#    wiz = Wizardz::Wizard.new({:unprocessed => [:first_state]})
+#    wiz.first_look?.should be_true
+#  end
+#
+#  it 'return false for the first_look? value (indicates if page should be validated)' do
+#    wiz = Wizardz::Wizard.new({:unprocessed => []})
+#    wiz.first_look?.should be_false
+#  end
+end

data/spec/wizardz_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+#describe "Wizardz" do
+#  it "fails" do
+#    fail "hey buddy, you should probably rename this file and start specing for real"
+#  end
+#end

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'wizardz'
+
+class Test::Unit::TestCase
+end

data/test/test_wizardz.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestWizardz < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

data/wizardz.gemspec

@@ -0,0 +1,67 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{wizardz}
+  s.version = "1.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["David Henry"]
+  s.date = %q{2010-06-08}
+  s.description = %q{Multi-Step wizard that deals with multiple models and changing step options based on previous step input}
+  s.email = %q{dave_henry@lyagushka.co.uk}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/wizardz.rb",
+     "lib/wizardz/page.rb",
+     "lib/wizardz/page/first.rb",
+     "lib/wizardz/wizard.rb",
+     "lib/wizardz/wizard_object.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/wizardz/page_spec.rb",
+     "spec/wizardz/wizard_spec.rb",
+     "spec/wizardz_spec.rb",
+     "test/helper.rb",
+     "test/test_wizardz.rb",
+     "wizardz.gemspec"
+  ]
+  s.homepage = %q{http://github.com/dwhenry/wizardz}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Multi-Step Wizard}
+  s.test_files = [
+    "spec/spec_helper.rb",
+     "spec/wizardz/page_spec.rb",
+     "spec/wizardz/wizard_spec.rb",
+     "spec/wizardz_spec.rb",
+     "test/helper.rb",
+     "test/test_wizardz.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: wizardz
+version: !ruby/object:Gem::Version 
+  hash: 21
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 1
+  version: 1.0.1
+platform: ruby
+authors: 
+- David Henry
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-08 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+description: Multi-Step wizard that deals with multiple models and changing step options based on previous step input
+email: dave_henry@lyagushka.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/wizardz.rb
+- lib/wizardz/page.rb
+- lib/wizardz/page/first.rb
+- lib/wizardz/wizard.rb
+- lib/wizardz/wizard_object.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/wizardz/page_spec.rb
+- spec/wizardz/wizard_spec.rb
+- spec/wizardz_spec.rb
+- test/helper.rb
+- test/test_wizardz.rb
+- wizardz.gemspec
+has_rdoc: true
+homepage: http://github.com/dwhenry/wizardz
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Multi-Step Wizard
+test_files: 
+- spec/spec_helper.rb
+- spec/wizardz/page_spec.rb
+- spec/wizardz/wizard_spec.rb
+- spec/wizardz_spec.rb
+- test/helper.rb
+- test/test_wizardz.rb