juice10-action_flow 0.1.0

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/lib/action_flow'

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/action_flow.rb

@@ -0,0 +1,59 @@
+%w[ blank_slate
+    expression
+    variable
+    flow
+    flow/controller
+    flow/state
+    helpers
+    filters
+].each do |file|
+  require File.dirname(__FILE__) + '/action_flow/' + file
+end
+
+module ActionFlow
+
+  class << self
+    def flows
+      @flows ||= {}
+    end
+
+    def configure(&block)
+      DSL.new(self, &block)
+    end
+  end
+
+  class DSL < BlankSlate
+    include Expression::Generator
+    
+    def initialize(flow_register, &block)
+      @flow_register = flow_register
+      instance_eval(&block)
+    end
+    
+    def flow(name, *expressions)
+      @flow_register.flows[name.to_sym] = Flow.new(expressions)
+    end
+    
+    def mutex(*names)
+      names.each do |name|
+        next unless flow = @flow_register.flows[name]
+        flow.mutexes = names - [name]
+      end
+    end
+
+    def terminate(*args)
+      expression_options = args.pop
+
+      unless expression_options.respond_to?(:[]) && expression = expression_options[:on]
+        raise ArgumentError, 'Could not find :on => expression in terminate'
+      end
+
+      args.each do |arg|
+        flow_name = arg.to_sym
+        next unless @flow_register.flows[flow_name]
+        @flow_register.flows[flow_name].terminators << expression
+      end
+    end
+  end
+
+end

data/lib/action_flow/blank_slate.rb

@@ -0,0 +1,33 @@
+module ActionFlow
+  class BlankSlate
+    
+    def self.include(mixin)
+      super(mixin)
+      @mixins ||= []
+      @mixins << mixin
+    end
+    
+    def self.new(*args, &block)
+      remove_inherited_methods
+      super(*args, &block)
+    end
+    
+    def self.remove_inherited_methods
+      modules = [self] + (@mixins || [])
+      
+      keepers = modules.inject([]) { |list, klass| list + all_methods(klass) } +
+                [:__id__, :__send__, :instance_eval]
+      
+      undef_method *( all_methods(self, true) - keepers )
+    end
+    
+    def self.all_methods(klass, include_ancestors = false)
+      %w[public protected private].map { |viz|
+        klass.__send__("#{viz}_instance_methods", include_ancestors)
+      }.
+      flatten.map { |m| m.to_sym }.uniq
+    end
+    
+  end
+end
+

data/lib/action_flow/expression.rb

@@ -0,0 +1,135 @@
+module ActionFlow
+  class Expression
+    
+    def initialize(controller, params, &block)
+      @params     = params.dup
+      @controller = (@params.delete(:controller) || controller).to_s
+      @action     = @params.delete(:action).to_s if @params[:action]
+      @format     = @params.delete(:format).to_s if @params[:format]
+      @matcher    = block
+    end
+    
+    def self.from_hash(hash)
+      new(nil, hash)
+    end
+    
+    def +(expression)
+      self.class::Group.new + self + expression
+    end
+    
+    def *(expression)
+      @format = expression.instance_eval { @controller }
+      @action = nil
+      self
+    end
+    
+    def /(expression)
+      expression.nesting = @controller
+      expression
+    end
+    
+    def nesting=(name)
+      @controller = "#{ name }/#{ @controller }"
+    end
+    
+    def method_missing(name, params = {}, &block)
+      @format = name.to_s if @action
+      @action ||= name.to_s
+      @params.update(params) if Hash === params
+      @matcher = block if block_given?
+      self
+    end
+    
+    def verb=(verb)
+      @verb = verb.to_s
+    end
+    
+    def ===(context)
+      p, req = context.params, context.request
+      
+      return false if (@controller != p[:controller].to_s)     or
+                      (@action and @action != p[:action].to_s) or
+                      (@verb and !req.__send__("#{ @verb }?")) or
+                      (@format and @format != p[:format].to_s)
+      
+      return false unless @params.all? do |key, value|
+        Variable === value ||
+        (value == p[key]) || (value == p[key].to_s) ||
+        (value === p[key]) || (value === p[key].to_i)
+      end
+      
+      @matcher ? context.instance_eval(&@matcher) : true
+    end
+    
+    def to_params(env = {})
+      options = {:controller => '/' + @controller}
+      options[:action] = @action || :index
+      options[:format] = @format if @format
+      
+      @params.each do |key, value|
+        value = value.lookup(env) if Variable === value
+        options[key] = value
+      end
+      
+      options
+    end
+    
+    def inspect
+      source = @controller.dup
+      source << ".#{ @action }" if @action
+      source << "(#{ @params.map { |k,v| ":#{k} => #{v.inspect}" } * ', ' })" unless @params.empty?
+      source << "#{ @action ? '.' : '*' }#{ @format }" if @format
+      source = "#{ @verb }(#{ source })" if @verb
+      source
+    end
+    
+    class Group
+      include Enumerable
+      
+      def initialize
+        @exprs = []
+      end
+      
+      def each(&block)
+        @exprs.each(&block)
+      end
+      
+      def +(expression)
+        Enumerable === expression ?
+            expression.each { |exp| @exprs << exp } :
+            @exprs << expression
+        self
+      end
+      
+      def verb=(verb)
+        each { |exp| exp.verb = verb }
+      end
+      
+      def ===(context)
+        any? { |exp| exp === context }
+      end
+    end
+    
+    module Generator
+      def method_missing(name, params = {}, &block)
+        Expression.new(name, params, &block)
+      end
+      
+      %w[get post put head delete].each do |verb|
+        module_eval <<-EOS
+          def #{verb}(*exprs, &block)
+            group = exprs.inject { |grp, exp| grp + exp }
+            group.verb = :#{verb}
+            group
+          end
+        EOS
+      end
+      
+      def find(symbol)
+        Variable.new(symbol)
+      end
+    end
+    
+  end
+end
+

data/lib/action_flow/filters.rb

@@ -0,0 +1,25 @@
+require 'forwardable'
+
+module ActionFlow
+  module Filters
+    
+    include Helpers
+    
+    def self.included(klass)
+      klass.before_filter :update_flow_status
+    end
+    
+  private
+    
+    def flow(name = nil)
+      flow_state = name.nil? ? flow_controller.current_flow : flow_controller.status[name]
+      flow_state.variables
+    end
+    
+    def update_flow_status
+      flow_controller.update_session!
+    end
+    
+  end
+end
+

data/lib/action_flow/flow.rb

@@ -0,0 +1,54 @@
+module ActionFlow
+  class Flow
+    
+    attr_accessor :mutexes, :terminators
+    
+    def initialize(expressions)
+      @expressions = expressions
+      @mutexes     = []
+      @terminators = []
+    end
+
+    def length
+      @expressions.length
+    end
+    
+    def begins_with?(context)
+      match_at?(0, context)
+    end
+    
+    def match_at?(index, context, exact = false)
+      return false unless expression = @expressions[index]
+      match_expression?(expression, context, exact)
+    end
+    
+    def match_expression?(expression, context, exact = false)
+      return expression.any? { |atom| match_expression?(atom, context, exact) } if Array === expression
+      return ActionFlow.flows[expression] === context if Symbol === expression and not exact
+      expression === context
+    end
+    
+    def ===(context)
+      @expressions.any? { |expr| match_expression?(expr, context) }
+    end
+
+    def terminates_on?(context)
+      @terminators.any? { |expr| expr === context }
+    end
+
+    def match_distance(index, context)
+      return 1000 unless expression = @expressions[index]
+      return 0 if expression === context
+      return 1 if Symbol === expression and ActionFlow.flows[expression] === context
+      1000
+    end
+    
+    def action_at(index, env, params = {})
+      return nil unless expression = @expressions[index]
+      return ActionFlow.flows[expression].action_at(0, env, params) if Symbol === expression
+      expression.to_params(env).merge(params)
+    end
+    
+  end
+end
+

data/lib/action_flow/flow/controller.rb

@@ -0,0 +1,91 @@
+require 'forwardable'
+
+module ActionFlow
+  class Flow
+    
+    class Controller
+      extend Forwardable
+      def_delegators :@context, :params, :session, :request
+      
+      def initialize(context)
+        @context = context
+        remove_legacy_objects_from_session!
+        load_states_from_session!
+      end
+      
+      def in_flow?(*names)
+        names.any? &status.method(:has_key?)
+      end
+      
+      def in_any_flow?
+        not status.empty?
+      end
+      
+      def current_flow(has_next = false)
+        status.values.
+        sort_by  { |state| state.match_distance(self) }.
+        find_all { |state| !has_next or state.next_action }.
+        first
+      end
+      
+      def update_session!
+        status.each { |name, state| state.progress!(self) }
+        
+        status.each do |name, state|
+          status.delete(name) if state.terminated? or state.complete?
+        end
+        
+        new_flow_candidates.each { |name| status[name] = State.new(name) }
+        
+        dump_states_to_session!
+      end
+      
+      def next_in_flow(*args)
+        flow_name = args.find { |arg| Symbol === arg } || nil
+        params    = args.find { |arg| Hash === arg }   || {}
+        
+        flow_state = status[flow_name] || current_flow(true)
+        flow_state ? flow_state.next_action(params) : nil
+      end
+      
+      def status
+        @states
+      end
+      
+    private
+      
+      def remove_legacy_objects_from_session!
+        return unless status = session[:flow_status]
+        flows = ActionFlow.flows
+        status.each do |key, value|
+          status.delete(key) unless Array === value and flows.has_key?(key)
+        end
+      end
+      
+      def load_states_from_session!
+        session_data = session[:flow_status] || {}
+        @states = session_data.inject({}) do |table, (flow_name, data)|
+          table[flow_name] = State.from_session_object(flow_name, data)
+          table
+        end
+      end
+      
+      def dump_states_to_session!
+        session[:flow_status] = @states.inject({}) do |table, (flow_name, state)|
+          table[flow_name] = state.to_session_object
+          table
+        end
+      end
+      
+      def new_flow_candidates
+        return nil unless flows = ActionFlow.flows
+        flows.keys.select do |name|
+          flows[name].begins_with?(self) and
+          not flows[name].mutexes.any?(&method(:in_flow?))
+        end
+      end
+    end
+    
+  end
+end
+

data/lib/action_flow/flow/state.rb

@@ -0,0 +1,73 @@
+module ActionFlow
+  class Flow
+    
+    class State
+      attr_reader :variables
+      
+      def initialize(flow_name)
+        @name       = flow_name
+        @flow       = ActionFlow.flows[flow_name]
+        @index      = 0
+        @max_index  = 0
+        @variables  = {}
+        @complete   = false
+        @terminated = false
+      end
+      
+      def match_distance(context)
+        @flow.match_distance(@index, context)
+      end
+      
+      def progress!(context)
+        if @flow.terminates_on?(context)
+          @terminated = true
+          return
+        end
+        @index += 1 if @flow.match_at?(@index + 1, context)
+        @max_index = [@max_index, @index].max
+        return if current_matches?(context)
+        
+        0.upto(@max_index) do |backtrack|
+          @index = backtrack if @flow.match_at?(backtrack, context)
+        end
+        
+        @complete = true if @index == @flow.length - 1
+      end
+      
+      def complete?
+        @complete
+      end
+
+      def terminated?
+        @terminated
+      end
+
+      def next_action(params = {})
+        @flow.action_at(@index + 1, variables, params)
+      end
+      
+      def to_session_object
+        [@index, @max_index, @variables, @complete]
+      end
+      
+      def self.from_session_object(flow_name, data)
+        instance = new(flow_name)
+        instance.instance_eval do
+          @index     = data[0]
+          @max_index = data[1]
+          @variables = data[2]
+          @complete  = data[3]
+        end
+        instance
+      end
+      
+    private
+      
+      def current_matches?(context)
+        @flow.match_at?(@index, context)
+      end
+    end
+    
+  end
+end
+