triggerable 0.1.0

data/lib/triggerable/conditions/predicate/predicate_condition.rb

@@ -0,0 +1,46 @@
+module Conditions
+  class PredicateCondition < Condition
+    attr_accessor :conditions
+
+    def initialize conditions
+      @conditions = conditions.map do |condition|
+        unless condition.is_a?(Hash)
+          condition
+        else
+          field     = condition.keys.first
+          statement = condition.values.first
+
+          Condition.build({field => statement})
+        end
+      end
+    end
+
+    def scope table
+      predicate_scope = nil
+
+      @conditions.each_with_index do |condition, index|
+        condition_scope = condition.scope(table)
+
+        predicate_scope = if index.zero?
+          condition_scope
+        else
+          predicate_scope.send(predicate_name, condition_scope)
+        end
+      end
+
+      predicate_scope
+    end
+
+    protected
+
+    def predicate_name
+      self.class.name.demodulize.downcase
+    end
+
+    def true_conditions object
+      @conditions.select do |c|
+        c.is_a?(Symbol) ? object.send(c) : c.true_for?(object)
+      end
+    end
+  end
+end

data/lib/triggerable/conditions/schedule/after.rb

@@ -0,0 +1,28 @@
+module Conditions
+  class After < ScheduleCondition
+    def from
+      case @math_condition
+      when :greater_than, :less_than
+        Time.now - @value
+      when nil
+        automation_time - @value - Engine.interval
+      end
+    end
+
+    def to
+      automation_time - @value
+    end
+
+    private
+    def condition
+      return super if @math_condition.blank?
+
+      case @math_condition
+      when :greater_than
+        LessThanOrEqualTo.new(@field, from)
+      when :less_than
+        GreaterThanOrEqualTo.new(@field, from)
+      end
+    end
+  end
+end

data/lib/triggerable/conditions/schedule/before.rb

@@ -0,0 +1,35 @@
+module Conditions
+  class Before < ScheduleCondition
+    def from
+      case @math_condition
+      when :greater_than
+        Time.now
+      when :less_than
+        Time.now + @value
+      when nil
+        automation_time + @value
+      end
+    end
+
+    def to
+      case @math_condition
+      when :greater_than
+        Time.now + @value
+      when nil
+        automation_time + @value + Engine.interval
+      end
+    end
+
+    private
+    def condition
+      return super if @math_condition.blank?
+
+      case @math_condition
+      when :greater_than
+        And.new([GreaterThanOrEqualTo.new(@field, from), LessThan.new(@field, to)])
+      when :less_than
+        GreaterThanOrEqualTo.new(@field, from)
+      end
+    end
+  end
+end

data/lib/triggerable/conditions/schedule/schedule_condition.rb

@@ -0,0 +1,33 @@
+module Conditions
+  class ScheduleCondition < FieldCondition
+    def initialize field, value
+      super
+      if value.is_a?(Hash)
+        @math_condition = value.keys.first
+        @value = value.values.first
+      end
+    end
+
+    def true_for? object
+      condition.true_for?(object)
+    end
+
+    def scope table
+      condition.scope(table)
+    end
+
+    protected
+    # automation_time is Time.now rounded by Engine.interval
+    def automation_time
+      i = Engine.interval
+      Time.at((Time.now.to_i / i) * i).utc
+    end
+
+    def condition
+      And.new [
+        GreaterThanOrEqualTo.new(@field, from),
+        LessThan.new(@field, to)
+      ]
+    end
+  end
+end

data/lib/triggerable/engine.rb

@@ -0,0 +1,28 @@
+class Engine
+  cattr_accessor :triggers, :automations, :interval
+
+  self.triggers = []
+  self.automations = []
+
+  def self.trigger model, options, block
+    self.triggers << Rules::Trigger.new(model, options, block)
+  end
+
+  def self.automation model, options, block
+    self.automations << Rules::Automation.new(model, options, block)
+  end
+
+  def self.triggers_for model, callback
+    triggers.select{|t| t.model == model && t.callback == callback }
+  end
+
+  def self.run_automations interval
+    self.interval = interval
+    automations.each(&:execute!)
+  end
+
+  def self.clear
+    self.triggers = []
+    self.automations = []
+  end
+end

data/lib/triggerable/rules/automation.rb

@@ -0,0 +1,13 @@
+module Rules
+  class Automation < Rule
+    def execute!
+      table = Arel::Table.new(model.table_name)
+      scope = @condition.scope(table)
+      query = table.where(scope).project(Arel.sql('id')).to_sql
+      ids = ParentModel.connection.execute(query).map { |r| r['id'] }
+      models = model.where(id: ids)
+
+      models.each {|o| actions.each {|a| a.run_for!(o)} }
+    end
+  end
+end

data/lib/triggerable/rules/rule.rb

@@ -0,0 +1,11 @@
+module Rules
+  class Rule
+    attr_accessor :model, :condition, :actions
+
+    def initialize model, options, block
+      @model     = model
+      @condition = Conditions::Condition.build(options[:if])
+      @actions   = Triggerable::Action.build(block || options[:do])
+    end
+  end
+end

data/lib/triggerable/rules/trigger.rb

@@ -0,0 +1,14 @@
+module Rules
+  class Trigger < Rule
+    attr_accessor :callback
+
+    def initialize model, options, block
+      super
+      @callback  = options[:on]
+    end
+
+    def execute! object
+      actions.each {|a| a.run_for!(object)} if condition.true_for?(object)
+    end
+  end
+end

data/lib/triggerable/version.rb

@@ -0,0 +1,3 @@
+module Triggerable
+  VERSION = '0.1.0'
+end

data/spec/conditions_spec.rb

@@ -0,0 +1,200 @@
+require 'spec_helper'
+
+describe Conditions do
+  before(:each) do
+    class Sample; attr_accessor(:field); end
+    @obj = Sample.new
+  end
+
+  context 'is' do
+
+    def check_value value
+      Conditions::Is.new(:field, value).true_for?(@obj)
+    end
+
+    def scope value
+      Conditions::Is.new(:field, value).scope
+    end
+
+    it 'integer' do
+      @obj.field = 1
+      expect(check_value(1)).to be_truthy
+
+      @obj.field = 2
+      expect(check_value(1)).to be_falsy
+    end
+
+    it 'string' do
+      @obj.field = '1'
+      expect(check_value('1')).to be_truthy
+
+      @obj.field = '2'
+      expect(check_value('1')).to be_falsy
+    end
+  end
+
+  context 'is_not' do
+
+    def check_value value
+      Conditions::IsNot.new(:field, value).true_for?(@obj)
+    end
+
+    def scope value
+      Conditions::IsNot.new(:field, value).scope
+    end
+
+    it 'integer' do
+      @obj.field = 1
+      expect(check_value(2)).to be_truthy
+
+      @obj.field = 2
+      expect(check_value(2)).to be_falsy
+    end
+
+    it 'string' do
+      @obj.field = '1'
+      expect(check_value('2')).to be_truthy
+
+      @obj.field = '2'
+      expect(check_value('2')).to be_falsy
+    end
+  end
+
+  context 'greater_than' do
+    def check_value value
+      Conditions::GreaterThan.new(:field, value).true_for?(@obj)
+    end
+
+    def scope value
+      Conditions::GreaterThan.new(:field, value).scope
+    end
+
+    it 'integer' do
+      @obj.field = 1
+
+      expect(check_value(-1)).to be_truthy
+      expect(check_value(0)).to  be_truthy
+      expect(check_value(1)).to  be_falsy
+      expect(check_value(2)).to  be_falsy
+    end
+
+    it 'float' do
+      @obj.field = 1.0
+
+      expect(check_value(0)).to   be_truthy
+      expect(check_value(0.9)).to be_truthy
+      expect(check_value(1.1)).to be_falsy
+      expect(check_value(2)).to   be_falsy
+    end
+  end
+
+  context 'less_than' do
+    def check_value value
+      Conditions::LessThan.new(:field, value).true_for?(@obj)
+    end
+
+    def scope value
+      Conditions::LessThan.new(:field, value).scope
+    end
+
+    it 'integer' do
+      @obj.field = 1
+
+      expect(check_value(-1)).to be_falsy
+      expect(check_value(0)).to  be_falsy
+      expect(check_value(1)).to  be_falsy
+      expect(check_value(2)).to  be_truthy
+    end
+
+    it 'float' do
+      @obj.field = 1.0
+
+      expect(check_value(0)).to   be_falsy
+      expect(check_value(0.9)).to be_falsy
+      expect(check_value(1.1)).to be_truthy
+      expect(check_value(2)).to   be_truthy
+    end
+  end
+
+  context 'in' do
+    def check_value value
+      Conditions::In.new(:field, value).true_for?(@obj)
+    end
+
+    def scope value
+      Conditions::In.new(:field, value).scope
+    end
+
+    it 'integer' do
+      @obj.field = 1
+
+      expect(check_value([0])).to    be_falsy
+      expect(check_value([1])).to    be_truthy
+      expect(check_value([1, 2])).to be_truthy
+    end
+
+    it 'float' do
+      @obj.field = 1.0
+
+      expect(check_value([0.0])).to      be_falsy
+      expect(check_value([1.0])).to      be_truthy
+      expect(check_value([1.0, 2.0])).to be_truthy
+    end
+
+    it 'string' do
+      @obj.field = '1'
+
+      expect(check_value(['0'])).to      be_falsy
+      expect(check_value(['1'])).to      be_truthy
+      expect(check_value(['1', '2'])).to be_truthy
+    end
+  end
+
+  context 'predicates' do
+    class TrueCondition
+      def true_for?(object); true; end
+    end
+
+    class FalseCondition
+      def true_for?(object); false; end
+    end
+
+    context 'and' do
+      before(:each) { @and_condition = Conditions::And.new([]) }
+
+      it ('true + true') do
+        @and_condition.conditions = [TrueCondition.new, TrueCondition.new]
+        expect(@and_condition.true_for?(@obj)).to be_truthy
+      end
+
+      it ('true + false') do
+        @and_condition.conditions = [TrueCondition.new, FalseCondition.new]
+        expect(@and_condition.true_for?(@obj)).to be_falsy
+      end
+
+      it ('true + false') do
+        @and_condition.conditions = [FalseCondition.new, FalseCondition.new]
+        expect(@and_condition.true_for?(@obj)).to be_falsy
+      end
+    end
+
+    context 'or' do
+      before(:each) { @or_condition = Conditions::Or.new([]) }
+
+      it ('true + true') do
+        @or_condition.conditions = [TrueCondition.new, TrueCondition.new]
+        expect(@or_condition.true_for?(@obj)).to be_truthy
+      end
+
+      it ('true + false') do
+        @or_condition.conditions = [TrueCondition.new, FalseCondition.new]
+        expect(@or_condition.true_for?(@obj)).to be_truthy
+      end
+
+      it ('true + false') do
+        @or_condition.conditions = [FalseCondition.new, FalseCondition.new]
+        expect(@or_condition.true_for?(@obj)).to be_falsy
+      end
+    end
+  end
+end

data/spec/integration/actions_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe 'Actions' do
+  before(:each) do
+    Engine.clear
+    TestTask.destroy_all
+  end
+
+  class CreateFollowUp < Triggerable::Action
+    def run_for! task
+      TestTask.create kind: 'follow up'
+    end
+  end
+
+  it 'custom action' do
+    TestTask.trigger on: :after_update, if: {status: 'solved'}, do: :create_follow_up
+
+    task = TestTask.create
+    expect(TestTask.count).to eq(1)
+
+    task.update_attributes status: 'solved'
+    expect(TestTask.count).to eq(2)
+    expect(TestTask.all.last.kind).to eq('follow up')
+  end
+
+  it 'custom action chain' do
+    TestTask.trigger on: :after_update, if: {status: 'solved'}, do: [:create_follow_up, :create_follow_up]
+
+    task = TestTask.create
+    expect(TestTask.count).to eq(1)
+
+    task.update_attributes status: 'solved'
+    expect(TestTask.count).to eq(3)
+    expect(TestTask.all[-2].kind).to eq('follow up')
+    expect(TestTask.all.last.kind).to eq('follow up')
+  end
+end