rule 0.0.2

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rule.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,64 @@
+= Rule
+
+== What is it?
+
+Rule is a state machine / rule engine. It does things.
+
+== How do I get started?
+
+1. Add it to your gemfile.
+
+    gem "rule", :git => "https://github.com/innovatis/rule"
+
+2. Add a "state" column and this code to your model:
+
+    rule_engine MyAwesomeRuleEngine
+
+3. create a file at app/rule_engines/my_awesome_rule_engine.rb
+
+    class MyAwesomeRuleEngine < Rule::Engine::Base
+     
+      state :new
+      state :ongoing
+      state :closed
+     
+      initial_state :new
+     
+      terminal_state :closed
+      
+      transition :new, :ongoing
+        validate IsInProgressRule
+      end 
+      
+      transition :ongoing, :closed
+        assert_presence_of object.closed_at, "Closed At" 
+      end 
+     
+    end 
+
+4. Create a file at app/rules/is_in_progress_rule.rb
+
+    class IsInProgressRule < Rule::Base
+      def validate
+        @object.in_progress.present?
+      end
+    end
+   
+5. Set your application up to run the rules.
+
+    # wherever it makes sense...
+    my_object.run_rules # advances state as far as possible and automatically saves
+
+== Explain all that stuff.
+
+Okay. 
+
+The Rule::Engine::Base subclass defines states and transitions. Each transition block contains a number of assertions and an optional priority. If any of the assertions does not pass, the state will not follow this transition. The priority decides which transition to use in the case of two possible transitions out of the current state both being valid. Use it by specifying "priority :high" or "priority :low" in the transition block.
+
+It often makes sense to bundle a group of assertions into a Rule class. These are defined in app/rules, and have a `validate` method containing assertions. In the future, rules will also have callbacks that fire when the state is advanced through a transition including that rule.
+
+If this didn't answer your questions, throw things at Burke until he explains.
+
+== Copyright
+
+Copyright (c) 2011 Burke Libbey / Innovatis. MIT License.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/rule.rb

@@ -0,0 +1,18 @@
+module Rule
+end
+
+path = File.dirname(__FILE__)
+$:.unshift(path) unless $:.include?(path)
+
+require 'rule/assertions'
+require 'rule/base'
+require 'rule/allow'
+require 'rule/disallow'
+require 'rule/engine/base'
+require 'rule/engine/invalid_transition'
+require 'rule/engine/state'
+require 'rule/engine/transition'
+
+require 'rule/active_record_extensions'
+require 'rule/engine/active_record'
+require 'rule/railtie'

data/lib/rule/active_record_extensions.rb

@@ -0,0 +1,12 @@
+class ActiveRecord::Base
+  def self.rule_engine(engine, opts={})
+    include(Rule::Engine::ActiveRecord)
+    column = opts[:column] || :state
+		if opts.delete(:before_save)
+			self.before_save :run_rules
+		end
+
+    @__rule_engine = engine.new(column)
+  end
+end
+

data/lib/rule/allow.rb

@@ -0,0 +1,10 @@
+module Rule
+  class Allow < Base
+    def validate
+      return true
+    end 
+  end 
+end 
+
+
+

data/lib/rule/assertions.rb

@@ -0,0 +1,21 @@
+module Rule
+  module Assertions
+    def assert(assertion, message)
+      unless assertion
+        add_error message
+      end 
+    end 
+    
+    def assert_presence_of(thing, name)
+      unless thing.present?
+        add_error "#{name} must be provided"
+      end 
+    end 
+
+    def assert_absence_of(thing, name)
+      unless thing.blank?
+        add_error "#{name} must be blank"
+      end 
+    end 
+  end 
+end 

data/lib/rule/base.rb

@@ -0,0 +1,21 @@
+module Rule
+
+  class Base
+    attr_reader :object
+    def initialize(object)
+      @object = object
+      @errors = []
+    end 
+    
+    def add_error(error)
+      @errors << error
+    end 
+
+    def pass?
+      validate != false and @errors.none?
+    end 
+    
+    include Rule::Assertions
+  end 
+end 
+

data/lib/rule/disallow.rb

@@ -0,0 +1,10 @@
+module Rule
+  class Disallow < Base
+    def validate
+      return false
+    end 
+  end 
+end 
+
+
+

data/lib/rule/engine/active_record.rb

@@ -0,0 +1,27 @@
+require 'active_support/concern'
+
+module Rule
+  module Engine
+    module ActiveRecord
+      extend ActiveSupport::Concern
+
+      included do
+        
+      end 
+      
+      module InstanceMethods
+        def run_rules
+          engine = self.class.instance_variable_get("@__rule_engine")
+          engine.run!(self)
+        end 
+      end 
+      
+      module ClassMethods
+        
+      end 
+      
+    end 
+  end 
+end 
+
+

data/lib/rule/engine/base.rb

@@ -0,0 +1,63 @@
+module Rule
+  module Engine
+    class Base
+
+      def initialize(column)
+        @column = column
+      end
+
+      def self.state(state)
+        find_or_create_state(state)
+      end
+
+      def self.initial_state(state)
+        @initial_state = find_or_create_state(state)
+      end
+
+      def self.terminal_state(state)
+        @terminal_states ||= []
+        @terminal_states << find_or_create_state(state)
+      end
+
+      def self.transition(from, to, &blk)
+        from_state = find_state!(from)
+        to_state   = find_state!(to)
+
+        from_state.add_transition(to_state, blk)
+      end
+
+      def run!(object)
+        # state = self.class.find_state(object.send(@column).try(:to_sym)) || self.class.instance_variable_get("@initial_state")
+        # Revalidate from initial state each time. This is more along the lines of the behaviour dave wants.
+        state = self.class.instance_variable_get("@initial_state")
+        loop do
+          prev_state = state
+          state = prev_state.next_state(object)
+          break if prev_state == state
+        end
+
+        object.send("#{@column}=", state.name)
+      end
+
+      private #################################################################
+
+      def self.find_or_create_state(name)
+        @states ||= []
+        unless state = @states.find { |state| state.name == name }
+          state = Rule::Engine::State.new(name)
+          @states << state
+        end
+        state
+      end
+
+      def self.find_state(name)
+        @states.find { |state| state.name == name }
+      end
+
+      def self.find_state!(name)
+        find_state(name) or raise "State #{name} not declared"
+      end
+
+    end
+  end
+end

data/lib/rule/engine/invalid_transition.rb

@@ -0,0 +1,3 @@
+class Rule::Engine::InvalidTransition < StandardError
+  
+end 

data/lib/rule/engine/state.rb

@@ -0,0 +1,46 @@
+module Rule
+  module Engine
+    class State
+
+      attr_reader :name
+      
+      def initialize(name)
+        @name = name
+        @transitions = []
+      end 
+          
+      def add_transition(to, blk)
+        @transitions << Transition.new(self, to, blk)
+      end 
+
+      def valid_transitions(object)
+        @transitions.map { |transition|
+          begin
+            transition.run!(object)
+          rescue Rule::Engine::InvalidTransition
+            nil
+          else 
+            transition
+          end 
+        }.compact
+      end 
+
+      def next_state(object)
+        transitions = valid_transitions(object)
+        if transitions.any?
+          return transitions.
+            sort_by{|transition| transition.instance_variable_get("@priority")}.
+            last.
+            to_state
+        else 
+          return self
+        end 
+      end 
+
+      
+    end 
+  end 
+end 
+
+
+

data/lib/rule/engine/transition.rb

@@ -0,0 +1,59 @@
+module Rule
+  module Engine
+    class Transition
+      attr_reader :from, :to, :action, :object
+      alias_method :to_state, :to
+      alias_method :from_state, :from
+      
+      PRIORITIES = { 
+        :min       => 0,
+        :very_low  => 1,
+        :low       => 3,
+        :normal    => 5,
+        :high      => 7,
+        :very_high => 9,
+        :max       => 10
+      }
+      
+      def initialize(from, to, action)
+        @from     = from
+        @to       = to
+        @action   = action
+        @priority = PRIORITIES[:normal]
+      end 
+      
+      def run!(object)
+        @object = object
+        action.bind(self).call
+      end 
+      
+      def add_error(error)
+        raise Rule::Engine::InvalidTransition
+      end 
+      
+      include Rule::Assertions
+      
+      def validate(rule_klass)
+        unless rule_klass.new(@object).pass?
+          raise Rule::Engine::InvalidTransition
+        end 
+      end 
+
+      def priority(priority)
+        case priority
+        when Numeric
+          @priority = priority
+        when Symbol
+          @priority = PRIORITIES[:normal]
+        else 
+          raise "Invalid priority"
+        end 
+      end 
+      
+    end 
+  end 
+end 
+
+
+
+

data/lib/rule/railtie.rb

@@ -0,0 +1,9 @@
+module Rule
+  class Railtie < Rails::Railtie
+    initializer 'rule.initialize' do |app|
+      app.config.autoload_paths += ["#{Rails.root}/app/rules/", "#{Rails.root}/app/rule_engines/"]
+    end
+  end 
+end 
+
+

data/lib/rule/version.rb

@@ -0,0 +1,3 @@
+module Rule
+  VERSION = "0.0.2"
+end

data/rule.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rule/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rule"
+  s.version     = Rule::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Burke Libbey"]
+  s.email       = ["burke@burkelibbey.org"]
+  s.homepage    = ""
+  s.summary     = %q{Rules on Rails}
+  s.description = %q{Rule Engine sort of thing for Rails.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: rule
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Burke Libbey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-21 00:00:00.000000000Z
+dependencies: []
+description: Rule Engine sort of thing for Rails.
+email:
+- burke@burkelibbey.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- lib/rule.rb
+- lib/rule/active_record_extensions.rb
+- lib/rule/allow.rb
+- lib/rule/assertions.rb
+- lib/rule/base.rb
+- lib/rule/disallow.rb
+- lib/rule/engine/active_record.rb
+- lib/rule/engine/base.rb
+- lib/rule/engine/invalid_transition.rb
+- lib/rule/engine/state.rb
+- lib/rule/engine/transition.rb
+- lib/rule/railtie.rb
+- lib/rule/version.rb
+- rule.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Rules on Rails
+test_files: []