self-control 0.0.0 → 0.1.0

data/README.rdoc

@@ -1,6 +1,10 @@
 = self-control
 
-Description goes here.
+State machines are awesome but sometimes you need a little more. Like who should do what in order for it to move on? How many steps are left? How can I restfully trigger the next event? Self Control adds route helpers, controller actions and a dsl to turn your existing state machines into full workflows. It is designed to use rails 3 with ActiveModel and should work with any state machine with just a few extra methods.
+
+== ToDo
+* Documentation
+* Tests
 
 == Note on Patches/Pull Requests
  
@@ -15,4 +19,4 @@ Description goes here.
 
 == Copyright
 
-Copyright (c) 2009 hexorx. See LICENSE for details.
+Copyright (c) 2011 hexorx. See LICENSE for details.

data/Rakefile

@@ -5,8 +5,8 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "self-control"
-    gem.summary = %Q{Sinatra extention to easily add RESTful routes for your models.}
-    gem.description = %Q{Self-Control provides default REST routes for your models.}
+    gem.summary = %Q{Self-Control builds on you existing state machine to create full work flows.}
+    gem.description = %Q{State machines are awesome but sometimes you need a little more. Like who should do what in order for it to move on? How many steps are left? How can I restfully trigger the next event? Self Control adds route helpers, controller actions and a dsl to turn your existing state machines into full workflows. It is designed to use rails 3 with ActiveModel and should work with any state machine with just a few extra methods.}
     gem.email = "hexorx@gmail.com"
     gem.homepage = "http://github.com/hexorx/self-control"
     gem.authors = ["hexorx"]

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.1.0

data/lib/self-control.rb

@@ -0,0 +1,50 @@
+require 'active_support'
+require 'self-control/exceptions'
+
+module SelfControl
+  extend ActiveSupport::Concern
+  
+  module ClassMethods
+    attr_reader :selfcontrol_list
+    attr_writer :selfcontrol_column
+    
+    def selfcontrol(state=nil, options={}, &block)
+      state = (state || options[:when]).to_sym
+      @selfcontrol_list ||= {}
+      @selfcontrol_list[state] = SelfControl::FlowBuilder.new(state, &block)
+    end
+    
+    alias :control_when :selfcontrol
+    
+    def selfcontrol_column
+      @selfcontrol_column ||= 'state'
+    end
+  end
+  
+  module InstanceMethods
+    def selfcontrol_list
+      self.class.selfcontrol_list
+    end
+    
+    def selfcontrol_column
+      self.class.selfcontrol_column
+    end
+        
+    def current_selfcontrol_state
+      (self.respond_to?(selfcontrol_column) ? self.send(selfcontrol_column) : :default).to_sym
+    end
+    
+    def selfcontrol(state=current_selfcontrol_state)
+      return unless builder = self.selfcontrol_list[state]
+      @selfcontrol_flows ||= {}
+      @selfcontrol_flows[state] ||= SelfControl::Flow.new(builder,self)
+    end
+  end
+  
+  autoload :FlowBuilder, 'self-control/flow_builder'
+  autoload :StepBuilder, 'self-control/step_builder'
+  autoload :Flow, 'self-control/flow'
+  autoload :Step, 'self-control/step'
+end
+
+require 'self-control/railtie' if defined?(Rails)

data/lib/self-control/controller_additions.rb

@@ -0,0 +1,82 @@
+module SelfControl
+  module ControllerAdditions
+    extend ActiveSupport::Concern
+    
+    module InstanceMethods      
+      def steps_list
+        @selfcontrol_steps = valid_selfcontrol? ? selfcontrol.steps_for(selfcontrol_actor) : []
+        respond_with(@selfcontrol_steps)
+      end
+      
+      def start_step        
+        authorize_selfcontrol_step!
+        
+        if action_methods.include?(params[:id])
+          send(params[:id])
+        else
+          render params[:id]
+        end
+      end
+      
+      def do_step
+        authorize_selfcontrol_step!
+        selfcontrol.do!(params[:id],params[:choose],params[:self_control_step])
+        respond_with(selfcontrol_resource, :location => selfcontrol_resource_location)
+      end
+
+    protected
+      
+      def default_selfcontrol_actor
+        respond_to?(:current_user) ? send(:current_user) : nil
+      end
+      
+      def selfcontrol_actor
+        @selfcontrol_actor ||= default_selfcontrol_actor
+      end
+      
+      def default_selfcontrol_resource
+        instance_name = params[:controller].sub("Controller", "").underscore.split('/').last.singularize
+        instance_variable_get("@#{instance_name}")
+      end
+      
+      def selfcontrol_resource
+        @selfcontrol_resource ||= default_selfcontrol_resource
+      end
+      
+      def selfcontrol_resource_location
+        selfcontrol_resource
+      end
+      
+      def selfcontrol
+        @selfcontrol ||= valid_selfcontrol? ? selfcontrol_resource.selfcontrol : nil
+      end
+
+      def selfcontrol_step
+        @selfcontrol_step ||= selfcontrol.nil? ? nil : selfcontrol[params[:id].to_sym]
+      end
+            
+      def valid_selfcontrol?
+        !selfcontrol_resource.nil? &&
+        selfcontrol_resource.respond_to?(:selfcontrol) &&
+        selfcontrol_resource.selfcontrol.is_a?(SelfControl::Flow)        
+      end
+      
+      def valid_selfcontrol_step?
+        !!selfcontrol_step
+      end
+      
+      def allow_selfcontrol_step?
+        return false unless selfcontrol.is_a?(SelfControl::Flow)
+        selfcontrol.allow? selfcontrol_actor, :to => params[:id]
+      end
+      
+      def authorize_selfcontrol_step!
+        raise SelfControl::NotImplemented.new() unless valid_selfcontrol_step?
+        unless allow_selfcontrol_step?
+          raise SelfControl::AccessDenied.new(nil, selfcontrol_actor, params[:step], params[:choose])
+        end
+      end
+        
+    end
+  end
+end

data/lib/self-control/exceptions.rb

@@ -0,0 +1,22 @@
+module SelfControl
+  class Error < StandardError; end
+
+  class NotImplemented < Error; end
+
+  class AccessDenied < Error
+    attr_reader :subject, :step, :action
+    attr_writer :default_message
+
+    def initialize(message=nil, subject=nil, step=nil, action=nil)
+      @message = message
+      @subject = subject
+      @step = step
+      @action = action
+      @default_message = "You are not authorized to access this step."
+    end
+
+    def to_s
+      @message || @default_message
+    end
+  end  
+end

data/lib/self-control/flow.rb

@@ -0,0 +1,70 @@
+module SelfControl
+  class Flow
+    attr_reader :builder, :model
+
+    delegate :actions, :total, :total_doable, :to => :@builder
+    
+    def initialize(builder, model)
+      @builder = builder
+      @model = model
+      @step_map = {}
+    end
+    
+    def [](name)
+      return if name.nil?
+      name = name.to_sym
+      @step_map[name] ||= steps.detect { |step| step.name == name }
+    end
+        
+    def steps
+      @steps ||= @builder.steps.map { |step| SelfControl::Step.new(step, self) }
+    end
+    
+    def steps_for(actor)
+      steps.select { |step| step.allow?(actor) }
+    end
+    
+    def next_steps_for(actor)
+      steps.detect { |step| step.doable? && !step.done? && step.allow?(actor) }
+    end
+    
+    def completed_steps
+      steps.select(&:done?)
+    end
+    
+    def total_completed
+      completed_steps.size
+    end
+    
+    def progress(options={})
+      count = (options[:of] || :all).to_sym == :doable ? total_doable : total 
+      
+      case (options[:as] || :percent).to_sym
+      when :percent
+        count == 0 ? 100 : (total_completed / count.to_f) * 100
+      when :decimal
+        count == 0 ? 1.0 : (total_completed / count)
+      when :array
+        [total_completed, count]
+      when :string
+        [total_completed, count].join(options[:with] || ' / ')
+      end
+    end
+    
+    def done?
+      total_completed == total_doable
+    end
+    
+    def allow?(actor=nil,options={})
+      return false unless step = self[options[:to]]
+      step.allow?(actor)
+    end
+
+    def do!(*args)
+      options = args.extract_options!
+      return false unless step = self[args[0]]
+      step.do!(args[1],options)
+    end
+  end
+end
+

data/lib/self-control/flow_builder.rb

@@ -0,0 +1,47 @@
+module SelfControl
+  class FlowBuilder
+    attr_accessor :state, :steps, :actors, :actions
+    
+    def initialize(state, &flow)
+      @state = state
+      @steps ||= []
+      @actors ||= []
+      @actions ||= []
+      
+      instance_eval(&flow)
+      
+      @actors = @actors.flatten.compact.uniq
+      @actions = @actions.flatten.compact.uniq
+    end
+    
+    def total
+      @steps.size
+    end
+    
+    def doable_steps
+      @steps.select(&:doable?)
+    end
+    
+    def total_doable
+      doable_steps.size
+    end
+    
+    private
+    
+    def the(actor, options)
+      step = SelfControl::StepBuilder.new(actor, options)
+      @steps.push(step)
+      @actors.push(step.actor)
+      @actions.concat(step.actions)
+    end
+    
+    def someone(options)
+      the(nil,options)
+    end
+    
+    def they(options)
+      the(@actors.last,options)
+    end
+  end
+end
+

data/lib/self-control/railtie.rb

@@ -0,0 +1,8 @@
+require 'self-control/route_helpers'
+require 'self-control/controller_additions'
+require 'self-control/step_adapter'
+
+module SelfControl
+  class Railtie < Rails::Railtie
+  end
+end

data/lib/self-control/route_helpers.rb

@@ -0,0 +1,17 @@
+module ActionDispatch::Routing
+  class Mapper
+    def selfcontrol
+      get 'steps', :action => 'steps_list', :as => 'self_control_steps_list'
+      get 'steps/:id', :action => 'start_step', :as => 'self_control_steps'
+      post 'steps/:id(/:choose)', :action => 'do_step', :as => 'self_control_steps'
+    end
+    
+    def control_resources(*resources, &block)
+      resources(*resources) do
+        selfcontrol
+        yield if block_given? 
+      end
+    end
+  end
+end
+

data/lib/self-control/step.rb

@@ -0,0 +1,60 @@
+module SelfControl
+  class Step
+    delegate :name, :default, :actions, :doable?, :meta, :to => :@builder
+
+    attr_accessor :model
+    
+    def initialize(builder, flow)
+      @builder = builder
+      @flow = flow
+      @model = flow.model
+    end
+    
+    def done?
+      doable? && condition?(@builder.if || true) &&  !condition?(@builder.unless || false)
+    end
+        
+    def condition?(attr)
+      return attr if attr.is_a?(Boolean)
+
+      result = if attr.is_a?(Proc)
+        attr.call(*[@model,@builder].take(attr.arity >= 0 ? attr.arity : 0))
+      elsif @model.respond_to?(attr)
+        @model.send(attr)
+      else
+        false
+      end
+
+      (result == 0 ? false : result.present?)
+    end
+    
+    def actor_method
+      return if @builder.actor.nil?
+      @builder.actor.to_sym
+    end
+    
+    def model_name
+      ActiveModel::Naming.singular(@model) if defined?(ActiveModel::Naming)
+    end
+    
+    def actor
+      return if actor_method.nil?
+      @model.respond_to?(actor_method) ? @model.send(actor_method) : nil
+    end
+    
+    def allow?(person=nil)
+      actor ? person == actor : true
+    end
+    
+    def do!(*args)
+      options = args.extract_options!
+      action = options.delete(:choose) || args[0] || default
+      return false unless action && actions.include?(action.to_sym) && @model.respond_to?(action)
+      
+      @model.attributes = options[model_name] if options[model_name]
+      @model.send(action)
+      @model.save
+    end    
+  end
+end
+

data/lib/self-control/step_adapter.rb

@@ -0,0 +1,25 @@
+module SelfControl
+  class Step
+    include ActiveModel::Conversion
+    include ActiveModel::Validations
+    extend ActiveModel::Naming
+    extend ActiveModel::Translation
+    
+    def persisted?
+      false
+    end
+    
+    def as_json(options={})
+      {
+        :name => name,
+        :actor => actor_method,
+        :actions => actions,
+        :default => default,
+        :doable => doable?,
+        :done => done?,
+        :meta => meta
+      }
+    end
+    
+  end
+end

data/lib/self-control/step_builder.rb

@@ -0,0 +1,23 @@
+module SelfControl
+  class StepBuilder
+    attr_accessor :actor, :default, :actions, :name, :if, :unless, :meta
+    
+    def initialize(actor, options)
+      @actor = actor
+      @actions = [*options.delete(:should)].flatten.compact.uniq.map(&:to_sym)
+      @default = options.delete(:action) || (@actions.size == 1 ? @actions.first : nil)
+      @name = (options.delete(:to) || @actions.join('_or_')).to_sym
+      
+      @if = options.delete(:if)
+      @unless = options.delete(:unless)
+      
+      @doable = !!(@if || @unless)
+      
+      @meta = options
+    end
+    
+    def doable?
+      @doable
+    end
+  end
+end

data/self-control.gemspec

@@ -0,0 +1,59 @@
+# 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{self-control}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["hexorx"]
+  s.date = %q{2011-06-20}
+  s.description = %q{State machines are awesome but sometimes you need a little more. Like who should do what in order for it to move on? How many steps are left? How can I restfully trigger the next event? Self Control adds route helpers, controller actions and a dsl to turn your existing state machines into full workflows. It is designed to use rails 3 with ActiveModel and should work with any state machine with just a few extra methods.}
+  s.email = %q{hexorx@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/self-control.rb",
+    "lib/self-control/controller_additions.rb",
+    "lib/self-control/exceptions.rb",
+    "lib/self-control/flow.rb",
+    "lib/self-control/flow_builder.rb",
+    "lib/self-control/railtie.rb",
+    "lib/self-control/route_helpers.rb",
+    "lib/self-control/step.rb",
+    "lib/self-control/step_adapter.rb",
+    "lib/self-control/step_builder.rb",
+    "self-control.gemspec",
+    "spec/self-control_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/hexorx/self-control}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Self-Control builds on you existing state machine to create full work flows.}
+
+  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<rspec>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+  end
+end
+

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: self-control
 version: !ruby/object:Gem::Version 
-  version: 0.0.0
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - hexorx
@@ -9,30 +15,38 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-13 00:00:00 -06:00
+date: 2011-06-20 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :development
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: yard
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
-    version: 
-description: Self-Control provides default REST routes for your models.
+  type: :development
+  version_requirements: *id002
+description: State machines are awesome but sometimes you need a little more. Like who should do what in order for it to move on? How many steps are left? How can I restfully trigger the next event? Self Control adds route helpers, controller actions and a dsl to turn your existing state machines into full workflows. It is designed to use rails 3 with ActiveModel and should work with any state machine with just a few extra methods.
 email: hexorx@gmail.com
 executables: []
 
@@ -43,12 +57,21 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - .document
-- .gitignore
 - LICENSE
 - README.rdoc
 - Rakefile
 - VERSION
 - lib/self-control.rb
+- lib/self-control/controller_additions.rb
+- lib/self-control/exceptions.rb
+- lib/self-control/flow.rb
+- lib/self-control/flow_builder.rb
+- lib/self-control/railtie.rb
+- lib/self-control/route_helpers.rb
+- lib/self-control/step.rb
+- lib/self-control/step_adapter.rb
+- lib/self-control/step_builder.rb
+- self-control.gemspec
 - spec/self-control_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
@@ -56,29 +79,34 @@ homepage: http://github.com/hexorx/self-control
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: Sinatra extention to easily add RESTful routes for your models.
-test_files: 
-- spec/self-control_spec.rb
-- spec/spec_helper.rb
+summary: Self-Control builds on you existing state machine to create full work flows.
+test_files: []
+

data/.gitignore

@@ -1,5 +0,0 @@
-*.sw?
-.DS_Store
-coverage
-rdoc
-pkg