juice10-action_flow 0.1.0

data/.document

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

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rcov (0.9.9)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  rcov
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Justin Halsall
+
+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/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 James Coglan
+
+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,206 @@
+= ActionFlow
+
+This Rails plugin provides a simple way to model multi-step processes
+such as wizards, sign-up flows, checkout processes and the like. It allows
+sequences to be easily composed and reordered, as well as letting you
+alter the behaviour and appearance of pages based on which flow they
+have been accessed through.
+
+== Contributing to action_flow
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Installation
+  
+  script/plugin install git://github.com/jcoglan/action_flow.git
+  
+  class ApplicationController < ActionController::Base
+    include ActionFlow::Filters
+  end
+  
+  module ApplicationHelper
+    include ActionFlow::Helpers
+  end
+
+
+== Specifying flows
+
+Setup is done using a +configure+ block which you can place anywhere
+is your application, though I'd recomment <tt>config/environment.rb</tt>
+or <tt>app/controllers/application.rb</tt>. The block is a list of flows,
+where each flow has a name and a list of controller actions. For example
+let's create a flow for importing contacts from Gmail. The flow allows
+you to import contacts, invite people to your site, and add people as
+friends.
+
+  ActionFlow.configure do
+    flow :import_contacts, contacts.import,
+                           contacts.invite,
+                           users.add_friends,
+                           contacts.done
+  end
+
+This tells +ActionFlow+ that the +import_contacts+ flow is the sequence
+of actions <tt>ContactsController#import</tt>, <tt>ContactsController#invite</tt>,
+<tt>UsersController#add_friends</tt> and <tt>ContactsController#done</tt>.
+On each request, +ActionFlow+ will watch the user's session and monitor
+which flows they are in and how far through each flow they've progressed.
+
+(The request-matching expressions <tt>contacts.import</tt> etc use the
+Consent request expression language. More information here:
+http://github.com/jcoglan/consent)
+
+A user is judged to have begun a flow when they hit the first action in
+that flow. They exit the flow when they've hit every page in the flow
+in sequence. Multiple flows may be in play at once, and requests that
+don't match any of the current flows are simply ignored: they do not
+cause a flow to exit.
+
+
+== Using flows to drive your app
+
++ActionFlow+ provides a few methods to controllers and views handle sending
+the user to the next step in the flow and detecting which flow they are in.
+
+<b><tt>next_in_flow(name)</tt></b> returns a params hash for the next action
+in the named flow, based on the user's session history. If +ActionFlow+
+cannot figure out the next action automatically, this method returns +nil+.
+
+In views it simply returns the params hash for making links:
+
+  <%= link_to "Skip this step", next_in_flow(:import_contacts) %>
+
+<b><tt>in_flow?(name)</tt></b> returns +true+ iff the user is in the named
+flow, allowing you to alter the behaviour of controllers or the appearance
+of views based on which flow(s) the user is currently in. This is especially
+useful when reusing flows through composition, as described below.
+
+
+== Composing flows
+
+Flows can be spliced together, allowing you to embed one sequence of actions
+inside another. Say we have a sign-up flow and we want to embed our contact
+importer from above within it.
+
+  ActionFlow.configure do
+    flow :import_contacts, contacts.import,
+                           contacts.invite,
+                           users.add_friends,
+                           contacts.done
+    
+    flow :signup,          users.new,
+                           post(users.create),
+                           :import_contacts,
+                           dashboard.show
+  end
+
+The <tt>signup</tt> flow begins with a request to <tt>UsersController#new</tt>,
+followed by a POST request to <tt>UsersController#create</tt>. The symbol
+<tt>:import_contacts</tt> that follows tells +ActionFlow+ to direct users
+to the start of the <tt>import_contacts</tt> flow after <tt>UsersController#create</tt>,
+whose implementation might look like this:
+
+  class UsersController < ApplicationController
+    def create
+      @user = User.new(params[:user])
+      return redirect_to next_in_flow(:signup) if @user.save
+    end
+  end
+
+If the new user is valid, we go to the next step, otherwise we fall through
+and render <tt>views/users/create.html.erb</tt> for them to correct the
+errors.
+
+While in the <tt>import_contacts</tt> flow, +ActionFlow+ will keep track
+of both flows that are in play, allowing the user to skip ahead within each
+flow. In your views, you can make use of this as follows:
+
+  # Links to ContactsController#invite
+  <%= link_to "Skip", next_in_flow(:import_contacts) %>
+  
+  # Links to DashboardController#show
+  <%= link_to "Skip", next_in_flow(:signup) %>
+
+
+== Flow conditions
+
+Flow conditions give you finer control over whether a request should progress
+a flow. You can attach a block of arbitrary Ruby code to request expressions
+to provide more matching control. For example you could only allow a certain
+flow to be entered if the first request is not an Ajax request:
+
+  ActionFlow.configure do
+    flow :signup, users.new { not request.xhr? },
+                  users.create,
+                  users.message
+  end
+
+
+== Mutually exclusive flows
+
+Sometimes you want two more flows to be mutually exclusive, for example if
+you're trying a few different orderings of a process in different parts of
+your application. The +mutex+ command takes a list of flow names and makes
+sure that only one flow in that list can be active at once.
+
+  ActionFlow.configure do
+    flow :signup, users.new,
+                  users.create,
+                  users.message
+
+    flow :alternate_signup, users.message,
+                            users.new,
+                            users.create
+    
+    mutex :signup, :alternate_signup
+  end
+
+This makes it easier to reason about which step ActionFlow will pick next
+since you know only one of these flows will apply at any time.
+
+
+== Flow variables
+
+Each flow a user is in gets its own session-like variable store, which
+allows data to be passed forward through a flow without having to
+store them as passthrough parameters in URLs. For example, say that
+I want to modify my app so that we go to <tt>/users/:username/profile</tt>
+at the end of the <tt>signup</tt> flow. We don't know the value of
+<tt>:username</tt> in advance, as it's determined during signup. But
+we can get +ActionFlow+ to redirect to the correct place using the
++find+ wrapper within our config and storing the needed data in the
+flow's "session".
+
+  ActionFlow.configure do
+    flow :signup,          users.new,
+                           post(users.create),
+                           profiles.show(:user_id => find(:username))
+  end
+  
+  class UsersController
+    def create
+      @user = User.new(params[:user])
+      if @user.save
+        flow[:username] = @user.username
+        redirect_to next_in_flow(:signup)
+      end
+    end
+  end
+
+Setting <tt>flow[:username]</tt> gives +ActionFlow+ the information
+it needs to fill in the details for the next request: assuming I
+signed up with the username "jcoglan", here +next_in_flow+
+redirects to <tt>{:controller => "profiles", :action => "show",
+:user_id => "jcoglan"}</tt>.
+
+
+== License
+
+Copyright (c) 2009 James Coglan, released under the MIT license
+

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "juice10-action_flow"
+  gem.homepage = "http://github.com/juice10/action_flow"
+  gem.license = "MIT"
+  gem.summary = %Q{ActionFlow provides a simple way to model multi-step processes such as wizards, sign-up flows, checkout processes in Rails. }
+  gem.description = %Q{ActionFlow provides a simple way to model multi-step processes such as wizards, sign-up flows, checkout processes and the like in Rails. It allows sequences to be easily composed and reordered, as well as letting you alter the behaviour and appearance of pages based on which flow they have been accessed through.}
+  gem.email = "justin@juice10.com"
+  gem.authors = ["Justin Halsall"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "action_flow #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/action_flow.gemspec

@@ -0,0 +1,149 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{action_flow}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Justin Halsall"]
+  s.date = %q{2011-04-19}
+  s.description = %q{ActionFlow provides a simple way to model multi-step processes such as wizards, sign-up flows, checkout processes and the like in Rails. It allows sequences to be easily composed and reordered, as well as letting you alter the behaviour and appearance of pages based on which flow they have been accessed through.}
+  s.email = %q{justin@juice10.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "MIT-LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "action_flow.gemspec",
+    "init.rb",
+    "install.rb",
+    "lib/action_flow.rb",
+    "lib/action_flow/blank_slate.rb",
+    "lib/action_flow/expression.rb",
+    "lib/action_flow/filters.rb",
+    "lib/action_flow/flow.rb",
+    "lib/action_flow/flow/controller.rb",
+    "lib/action_flow/flow/state.rb",
+    "lib/action_flow/helpers.rb",
+    "lib/action_flow/variable.rb",
+    "test/helper.rb",
+    "test/test_action_flow.rb",
+    "test_app/.gitignore",
+    "test_app/Gemfile",
+    "test_app/Gemfile.lock",
+    "test_app/README",
+    "test_app/Rakefile",
+    "test_app/app/controllers/application_controller.rb",
+    "test_app/app/controllers/settings_controller.rb",
+    "test_app/app/helpers/application_helper.rb",
+    "test_app/app/views/layouts/application.html.erb",
+    "test_app/app/views/settings/_step.html.erb",
+    "test_app/app/views/settings/intro.html.erb",
+    "test_app/app/views/settings/outro.html.erb",
+    "test_app/config.ru",
+    "test_app/config/application.rb",
+    "test_app/config/boot.rb",
+    "test_app/config/cucumber.yml",
+    "test_app/config/database.yml",
+    "test_app/config/environment.rb",
+    "test_app/config/environments/cucumber.rb",
+    "test_app/config/environments/development.rb",
+    "test_app/config/environments/production.rb",
+    "test_app/config/environments/test.rb",
+    "test_app/config/initializers/backtrace_silencers.rb",
+    "test_app/config/initializers/inflections.rb",
+    "test_app/config/initializers/mime_types.rb",
+    "test_app/config/initializers/secret_token.rb",
+    "test_app/config/initializers/session_store.rb",
+    "test_app/config/locales/en.yml",
+    "test_app/config/routes.rb",
+    "test_app/db/schema.rb",
+    "test_app/db/seeds.rb",
+    "test_app/features/flow_management.feature",
+    "test_app/features/flow_with_array_alternatives.feature",
+    "test_app/features/flows_with_conditions.feature",
+    "test_app/features/mutual_exclusion.feature",
+    "test_app/features/step_definitions/flow_steps.rb",
+    "test_app/features/step_definitions/url_steps.rb",
+    "test_app/features/step_definitions/web_steps.rb",
+    "test_app/features/support/env.rb",
+    "test_app/features/support/hooks.rb",
+    "test_app/features/support/paths.rb",
+    "test_app/features/support/selectors.rb",
+    "test_app/lib/tasks/.gitkeep",
+    "test_app/lib/tasks/cucumber.rake",
+    "test_app/public/404.html",
+    "test_app/public/422.html",
+    "test_app/public/500.html",
+    "test_app/public/favicon.ico",
+    "test_app/public/images/rails.png",
+    "test_app/public/index.html",
+    "test_app/public/javascripts/application.js",
+    "test_app/public/javascripts/controls.js",
+    "test_app/public/javascripts/dragdrop.js",
+    "test_app/public/javascripts/effects.js",
+    "test_app/public/javascripts/prototype.js",
+    "test_app/public/javascripts/rails.js",
+    "test_app/public/robots.txt",
+    "test_app/public/stylesheets/.gitkeep",
+    "test_app/script/about",
+    "test_app/script/console",
+    "test_app/script/cucumber",
+    "test_app/script/dbconsole",
+    "test_app/script/destroy",
+    "test_app/script/generate",
+    "test_app/script/performance/benchmarker",
+    "test_app/script/performance/profiler",
+    "test_app/script/plugin",
+    "test_app/script/rails",
+    "test_app/script/runner",
+    "test_app/script/server",
+    "test_app/test/performance/browsing_test.rb",
+    "test_app/test/test_helper.rb",
+    "test_app/vendor/plugins/.gitkeep",
+    "test_app/vendor/plugins/action_flow/init.rb",
+    "uninstall.rb"
+  ]
+  s.homepage = %q{http://github.com/juice10/action_flow}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.2}
+  s.summary = %q{ActionFlow provides a simple way to model multi-step processes such as wizards, sign-up flows, checkout processes in Rails.}
+  s.test_files = [
+    "test/helper.rb",
+    "test/test_action_flow.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+