stair_master 0.0.3 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 506012055f95599b09cc8307c34f2e27d675487a
+  data.tar.gz: ff08113af0b7cf528e65620339a93d0cc185eb64
+SHA512:
+  metadata.gz: 92d88d92f1be968effceec89a605880920cfbc7b13ebb7b1b6f60161868ccda46e427d1d7d0cbd786154601d9f5aac4b74ee0f541bd4173d8fd151a241b0c4fb
+  data.tar.gz: 6d840af01c7791e74cb6ffdcebf16b01b5447faf0168d7f8647f0d5914cd842a3ee6a11945a442191dce3664754dac66fba8f91fbe598dde7505f75ba93ed38e

data/{LICENSE → MIT-LICENSE}

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014 Digital Opera
+Copyright (c) 2014 Digital Opera LLC
 
 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

data/README.md

@@ -43,9 +43,8 @@ The named route for the path of this step.
 
 **conditions** :hash
 
-Define the conditions that are to be used when resolving which steps will be available, and/or should be skipped based on the current context.  Available conditions are:
+Define the conditions that are to be used when resolving which steps will be available, and/or should be skipped based on the current context. Available conditions are:
 
-- available_if/unless
 - skip_if/unless
 
 **Note** we recommend placing your maps in `app/maps` however you can place them where ever you would like.
@@ -55,9 +54,9 @@ Define the conditions that are to be used when resolving which steps will be ava
 #
 class MyProcessMap < StairMaster::WorkflowMap
     # We must override the define_map! method with our mapping rules
-    add_step :home, "First Step", :first_step_path, available_if: :method_name
+    add_step :home, "First Step", :first_step_path, skip_if: :method_name
     ...
-    
+
     set_order :home, ...
 end
 ```
@@ -72,7 +71,7 @@ When setting up your controllers, we would recommend setting up a base controlle
 class MyProcess::BaseController < ApplicationController
     # Include the stair master controller concern
     include StairMaster::Controller
-    
+
     # Tell stair master what map to use
     stair_master_map_class MyProcessMap
 end
@@ -85,7 +84,7 @@ end
 class MyProcess::HomeController < MyProcess::BaseController
     def show
     end
-    
+
     def update
     end
 end

data/Rakefile

@@ -19,11 +19,11 @@ load 'rails/tasks/engine.rake'
 
 Bundler::GemHelper.install_tasks
 
+Dir[File.join(File.dirname(__FILE__), 'lib/tasks/**/*.rake')].each {|f| load f }
+
 require 'rspec/core'
 require 'rspec/core/rake_task'
 
-Dir[File.join(File.dirname(__FILE__), 'lib/tasks/**/*.rake')].each {|f| load f }
-
 desc "Run all specs in spec directory (excluding plugin specs)"
 RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
 task :default => :spec

data/app/concerns/stair_master/controller.rb

@@ -14,11 +14,25 @@ module StairMaster
 
     included do
       helper_method :workflow_map, :params_for_redirect
-      before_filter :check_step_availability, only: [:show, :update]
+      before_filter :check_step_skippable, only: [:show, :update]
+
+      class << self
+        attr_reader :stair_master_workflow_map
+      end
     end
 
     def workflow_map
-      @stair_master_workflow_map ||= self.class.workflow_map.new
+      @workflow_map ||= (
+        @stair_master_workflow_map ||= (
+          self.class.ancestors.map do |a|
+            a.stair_master_workflow_map if a.respond_to? :stair_master_workflow_map
+          end.flatten.compact.first
+        )
+
+        map = @stair_master_workflow_map.present? ? @stair_master_workflow_map : self.class.workflow_map
+
+        map.new
+      )
     end
 
     private # ---------------------------------------------
@@ -34,18 +48,14 @@ module StairMaster
       mod_params.empty? ? nil : mod_params
     end
 
-    def check_step_availability
-      if is_available_step?
-        redirect_to next_step_path(params_for_redirect) if step_should_be_skipped?
-      else
-        redirect_to first_step_path(params_for_redirect)
-      end
+    def check_step_skippable
+      redirect_to next_step_path(params_for_redirect) if step_should_be_skipped?
     end
 
     module ClassMethods
       def workflow_map(map_class=nil)
-        return (@@stair_master_workflow_map || ::StairMaster::WorkflowMap) if map_class.nil?
-        @@stair_master_workflow_map = map_class.to_s.camelize.constantize
+        return (@stair_master_workflow_map || ::StairMaster::WorkflowMap) if map_class.nil?
+        @stair_master_workflow_map = map_class.to_s.camelize.constantize
       end
     end
   end

data/lib/stair_master/concerns/ordering.rb

@@ -12,12 +12,7 @@ module StairMaster
       end
 
       def available_steps
-        @stair_master_available_steps ||= workflow_map.order.map{ |step_name| step_name if step_is_available?(step_name) }.compact
-      end
-
-      def step_is_available?(step_name)
-        step = get_step_by_name(step_name)
-        step.available?(self)
+        @stair_master_available_steps ||= workflow_map.order.map{ |step_name| step_name }.compact
       end
     end
   end

data/lib/stair_master/concerns/tests.rb

@@ -29,11 +29,6 @@ module StairMaster
         step_name == available_steps.first
       end
 
-      def is_available_step?(step=nil)
-        step_name = step.nil? ? controller_name.to_sym : step.key
-        available_steps.include? step_name
-      end
-
       def step_should_be_skipped?(step=nil)
         step = step.nil? ? current_step : step
         step.skip?(self)

data/lib/stair_master/concerns/traversal.rb

@@ -54,7 +54,7 @@ module StairMaster
       end
 
       ## Previous Step ------------------------------------
-      def previous_step_index(base_step_index=nil)
+      def previous_step_index
         @stair_master_previous_step_index ||= get_previous_step_index
       end
 

data/lib/stair_master/conditions.rb

@@ -1,7 +1,6 @@
 # app/stair_master/conditions.rb
 
 require_relative "conditions/base"
-require_relative "conditions/availability"
 require_relative "conditions/skippable"
 
 module StairMaster

data/lib/stair_master/conditions/base.rb

@@ -16,14 +16,6 @@ module StairMaster
 
       ## Methods ------------------------------------------
 
-      def available?
-        raise NotImplmenetedError
-      end
-
-      def not_available?
-        raise NotImplmenetedError
-      end
-
       def description
         raise NotImplementedError
       end

data/lib/stair_master/step.rb

@@ -13,11 +13,6 @@ module StairMaster
 
     ## Methods --------------------------------------------
 
-    def available?(context)
-      rules = @conditions[:availability]
-      ( rules.empty? ? [true] : test_rules(rules, context) ).all?
-    end
-
     def skip?(context)
       rules = @conditions[:skippable]
       ( rules.empty? ? [false] : test_rules(rules, context) ).all?
@@ -47,15 +42,12 @@ module StairMaster
 
     def build_conditions(conditions)
       conditions          = conditions.empty? ? {} : conditions.first
-      availability_rules  = []
       skip_rules          = []
 
       conditions.each do |k,v|
         condition_type, type = k.to_s.split('_').map{ |v| v.to_sym }
 
-        if condition_type == :available ## It is an "availability" condition
-          availability_rules << ::StairMaster::Conditions::Availability.new(self, type, v)
-        elsif condition_type == :skip   ## It is a "skip" condition
+        if condition_type == :skip   ## It is a "skip" condition
           skip_rules << ::StairMaster::Conditions::Skippable.new(self, type, v)
         else
           ## We don't know what this type of condition is so raise an exception
@@ -63,7 +55,7 @@ module StairMaster
         end
       end
 
-      { availability: availability_rules, skippable: skip_rules }
+      { skippable: skip_rules }
     end
   end
 end

data/lib/stair_master/version.rb

@@ -1,3 +1,3 @@
 module StairMaster
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/spec/controllers/base/ordering_spec.rb

@@ -13,28 +13,5 @@ describe 'ordering methods' do
         subject.available_steps.should eq [:step_one, :step_two, :step_three]
       end
     end
-
-    describe '#step_is_available?' do
-      it 'should return true if in list' do
-        get :show
-
-        subject.should be_step_is_available(:step_one)
-        subject.should be_step_is_available(:step_two)
-        subject.should be_step_is_available(:step_three)
-      end
-
-      it 'should return false if not available' do
-        StairMaster::Step.any_instance.stubs(:available?).returns(false)
-        get :show
-
-        subject.should_not be_step_is_available(:step_one)
-      end
-
-      it 'should throw error if not apart of inital list' do
-        get :show
-
-        expect{ subject.step_is_available?(:step_four) }.to raise_error
-      end
-    end
   end
 end

data/spec/controllers/base/skip_if_spec.rb

@@ -0,0 +1,395 @@
+require 'spec_helper'
+
+describe 'when skip_if condition is defined' do
+  describe '#previous_step' do
+    context 'when second step' do
+      context 'when should NOT be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepTwoController.new
+        }
+
+        it 'should get step 1' do
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_two?).returns(false)
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_one?).returns(false)
+          get :show
+
+          expect(subject.previous_step.label).to eq 'Step 1'
+        end
+      end
+
+      context 'when should be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepTwoController.new
+        }
+
+        it 'should return nil' do
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_two?).returns(false)
+          get :show
+
+          expect(subject.previous_step).to be_nil
+        end
+      end
+    end
+
+    context 'when third step' do
+      context 'when should NOT be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepThreeController.new
+        }
+
+        it 'should get step 2' do
+          SkipIf::StepThreeController.any_instance.stubs(:skip_step_two?).returns(false)
+          SkipIf::StepThreeController.any_instance.stubs(:skip_step_three?).returns(false)
+          get :show
+
+          expect(subject.previous_step.label).to eq 'Step 2'
+        end
+      end
+
+      context 'when should be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepThreeController.new
+        }
+
+        it 'should return step 1' do
+          SkipIf::StepThreeController.any_instance.stubs(:skip_step_one?).returns(false)
+          SkipIf::StepThreeController.any_instance.stubs(:skip_step_three?).returns(false)
+          get :show
+
+          expect(subject.previous_step.label).to eq 'Step 1'
+        end
+      end
+    end
+  end
+
+  describe '#previous_step_index' do
+    context 'when second step' do
+      context 'when should NOT be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepTwoController.new
+        }
+
+        it 'should get step 1 index' do
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_two?).returns(false)
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_one?).returns(false)
+          get :show
+
+          expect(subject.previous_step_index).to eq 0
+        end
+      end
+
+      context 'when should be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepTwoController.new
+        }
+
+        it 'should return nil' do
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_two?).returns(false)
+          get :show
+
+          expect(subject.previous_step_index).to be_nil
+        end
+      end
+    end
+
+    context 'when third step' do
+      context 'when should NOT be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepThreeController.new
+        }
+
+        it 'should get step 2 index' do
+          SkipIf::StepThreeController.any_instance.stubs(:skip_step_two?).returns(false)
+          SkipIf::StepThreeController.any_instance.stubs(:skip_step_three?).returns(false)
+          get :show
+
+          expect(subject.previous_step_index).to eq 1
+        end
+      end
+
+      context 'when should be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepThreeController.new
+        }
+
+        it 'should return step 1 index' do
+          SkipIf::StepThreeController.any_instance.stubs(:skip_step_one?).returns(false)
+          SkipIf::StepThreeController.any_instance.stubs(:skip_step_three?).returns(false)
+          get :show
+
+          expect(subject.previous_step_index).to eq 0
+        end
+      end
+    end
+  end
+
+  describe '#previous_step_name' do
+    context 'when first step' do
+      before(:all) {
+        @controller = SkipIf::StepOneController.new
+      }
+
+      it 'should return nil' do
+        SkipIf::StepOneController.any_instance.stubs(:skip_step_one?).returns(false)
+        get :show
+
+        expect(subject.previous_step_name).to be_nil
+      end
+    end
+
+    context 'when second step' do
+      context 'when should NOT be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepTwoController.new
+        }
+
+        it 'should get step 1 name' do
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_two?).returns(false)
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_one?).returns(false)
+          get :show
+
+          expect(subject.previous_step_name).to eq :step_one
+        end
+      end
+
+      context 'when should be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepTwoController.new
+        }
+
+        it 'should return nil' do
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_two?).returns(false)
+          get :show
+
+          expect(subject.previous_step_name).to be_nil
+        end
+      end
+    end
+
+    context 'when third step' do
+      context 'when should NOT be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepThreeController.new
+        }
+
+        it 'should get step 2 name' do
+          SkipIf::StepThreeController.any_instance.stubs(:skip_step_two?).returns(false)
+          SkipIf::StepThreeController.any_instance.stubs(:skip_step_three?).returns(false)
+          get :show
+
+          expect(subject.previous_step_name).to eq :step_two
+        end
+      end
+
+      context 'when should be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepThreeController.new
+        }
+
+        it 'should return step 1 name' do
+          SkipIf::StepThreeController.any_instance.stubs(:skip_step_one?).returns(false)
+          SkipIf::StepThreeController.any_instance.stubs(:skip_step_three?).returns(false)
+          get :show
+
+          expect(subject.previous_step_name).to eq :step_one
+        end
+      end
+    end
+  end
+
+  describe '#next_step' do
+    context 'when first step' do
+      context 'when should NOT be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepOneController.new
+        }
+
+        it 'should return step 2' do
+          SkipIf::StepOneController.any_instance.stubs(:skip_step_one?).returns(false)
+          SkipIf::StepOneController.any_instance.stubs(:skip_step_two?).returns(false)
+          get :show
+
+          expect(subject.next_step.label).to eq 'Step 2'
+        end
+      end
+
+      context 'when should be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepOneController.new
+        }
+
+        it 'should return step 3' do
+          SkipIf::StepOneController.any_instance.stubs(:skip_step_one?).returns(false)
+          SkipIf::StepOneController.any_instance.stubs(:skip_step_three?).returns(false)
+          get :show
+
+          expect(subject.next_step.label).to eq 'Step 3'
+        end
+      end
+    end
+
+    context 'when second step' do
+      context 'when should NOT be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepTwoController.new
+        }
+
+        it 'should get step 3' do
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_two?).returns(false)
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_three?).returns(false)
+          get :show
+
+          expect(subject.next_step.label).to eq 'Step 3'
+        end
+      end
+
+      context 'when should be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepTwoController.new
+        }
+
+        it 'should return nil' do
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_two?).returns(false)
+          get :show
+
+          expect(subject.next_step).to be_nil
+        end
+      end
+    end
+  end
+
+  describe '#next_step_index' do
+    context 'when first step' do
+      context 'when should NOT be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepOneController.new
+        }
+
+        it 'should return step 2 index' do
+          SkipIf::StepOneController.any_instance.stubs(:skip_step_one?).returns(false)
+          SkipIf::StepOneController.any_instance.stubs(:skip_step_two?).returns(false)
+          get :show
+
+          expect(subject.next_step_index).to eq 1
+        end
+      end
+
+      context 'when should be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepOneController.new
+        }
+
+        it 'should return step 3 index' do
+          SkipIf::StepOneController.any_instance.stubs(:skip_step_one?).returns(false)
+          SkipIf::StepOneController.any_instance.stubs(:skip_step_three?).returns(false)
+          get :show
+
+          expect(subject.next_step_index).to eq 2
+        end
+      end
+    end
+
+    context 'when second step' do
+      context 'when should NOT be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepTwoController.new
+        }
+
+        it 'should get step 3 index' do
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_two?).returns(false)
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_three?).returns(false)
+          get :show
+
+          expect(subject.next_step_index).to eq 2
+        end
+      end
+
+      context 'when should be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepTwoController.new
+        }
+
+        it 'should return nil' do
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_two?).returns(false)
+          get :show
+
+          expect(subject.next_step_index).to be_nil
+        end
+      end
+    end
+  end
+
+  describe '#next_step_name' do
+    context 'when first step' do
+      context 'when should NOT be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepOneController.new
+        }
+
+        it 'should return step_two' do
+          SkipIf::StepOneController.any_instance.stubs(:skip_step_one?).returns(false)
+          SkipIf::StepOneController.any_instance.stubs(:skip_step_two?).returns(false)
+          get :show
+
+          expect(subject.next_step_name).to eq :step_two
+        end
+      end
+
+      context 'when should be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepOneController.new
+        }
+
+        it 'should return step_three' do
+          SkipIf::StepOneController.any_instance.stubs(:skip_step_one?).returns(false)
+          SkipIf::StepOneController.any_instance.stubs(:skip_step_three?).returns(false)
+          get :show
+
+          expect(subject.next_step_name).to eq :step_three
+        end
+      end
+    end
+
+    context 'when second step' do
+      context 'when should NOT be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepTwoController.new
+        }
+
+        it 'should return step_three' do
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_two?).returns(false)
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_three?).returns(false)
+          get :show
+
+          expect(subject.next_step_name).to eq :step_three
+        end
+      end
+
+      context 'when should be skipped' do
+        before(:all) {
+          @controller = SkipIf::StepTwoController.new
+        }
+
+        it 'should return nil' do
+          SkipIf::StepTwoController.any_instance.stubs(:skip_step_two?).returns(false)
+          get :show
+
+          expect(subject.next_step_name).to be_nil
+        end
+      end
+    end
+
+    context 'when third step' do
+      before(:all) {
+        @controller = SkipIf::StepThreeController.new
+      }
+
+      it 'should return nil' do
+        SkipIf::StepThreeController.any_instance.stubs(:skip_step_three?).returns(false)
+        get :show
+
+        expect(subject.next_step_name).to be_nil
+      end
+    end
+  end
+end