switcher 0.0.1.beta → 0.1.0

data/.gitignore

@@ -2,3 +2,4 @@
 .bundle
 Gemfile.lock
 pkg/*
+.rvmrc

data/Gemfile

@@ -2,3 +2,10 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in switcher.gemspec
 gemspec
+
+gem "guard-rspec"
+
+group "activerecord" do
+  gem "activerecord", "~> 3.0.0"
+  gem "sqlite3"
+end

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec', :version => 2, :all_after_pass => true, :all_on_start => true,
+  :cli => "--colour --format documentation --profile" do
+  watch(%r{^lib/(.+)\.rb$})
+  watch(%r{^spec/.+_spec\.rb$})
+end

data/README.md

@@ -1,3 +1,17 @@
-TODO - write README
+Not for production use
 
-See specs
+Docs: See specs
+
+## TODO:
+
+* 1.8 compat
+* Write README
+* Refactoring
+* Events without state
+* Ability to define validations, associations etc. in state (ability to call static methods from object)
+
+## Adapters TODO:
+
+* ActiveModel
+* Virtus
+* Mongoid

data/lib/switcher/adapters/active_record.rb

@@ -0,0 +1,78 @@
+module Switcher
+  module ActiveRecord
+
+    module Initializer
+    end
+
+    module ClassMethods
+      def switcher_pre_initialize(inst, spec)
+        inst.class_eval do
+          spec_name = spec.name
+
+          define_method(:"#{spec_name}_spec") { spec }
+          define_method(:"#{spec_name}_prev") { self.instance_variable_get(:"@#{spec_name}_statement").state_prev }
+
+          define_method(:"#{spec_name}") { self.instance_variable_get(:"@#{spec_name}_statement").state_current }
+
+          events = []
+
+          spec.states.each_pair do |state_name, state|
+            define_method(:"#{spec_name}_#{state_name}?") do
+              state_name == self.send(:"#{spec_name}")
+            end
+
+            events << state.event_names
+          end
+
+          events.flatten.each do |event_name|
+            define_method(:"can_#{event_name}?") do
+              self.class.class_variable_get(:@@__specs__).map { |spc|
+                spc.states[self.send(:"#{spc.name}")].event_names.include?(event_name)
+              }.include?(true)
+            end
+
+            define_method(:"#{event_name}!") do |*args|
+              switch_from(nil, event_name, *args)
+            end
+          end
+
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend Switcher::ClassMethods
+      base.extend Switcher::ActiveRecord::ClassMethods
+
+      base.class_eval do
+        after_initialize do
+          self.class.class_variable_get(:@@__specs__).each do |spec|
+            spec_name     = spec.name
+            state_current = read_attribute(spec_name)
+            state_prev    = (has_attribute?("#{spec_name}_prev") ? read_attribute("#{spec_name}_prev") : nil)
+
+            self.instance_variable_set(:"@#{spec_name}_statement", Statement.new(self, spec, state_current, state_prev))
+          end
+        end
+      end
+    end
+
+    def switch(event, *args)
+      switch_from(self.class, event, *args)
+    end
+
+    def switch_from(orig, event, *args)
+      self.class.class_variable_get(:@@__specs__).each do |spc|
+        spc_name = spc.name
+
+        self.instance_variable_get(:"@#{spc_name}_statement").publish(event, orig, args)
+
+        write_attribute(spc_name, self.send(:"#{spc_name}"))
+        if has_attribute?("#{spc_name}_prev")
+          write_attribute("#{spc_name}_prev", self.send(:"#{spc_name}_prev"))
+        end
+      end
+    end
+
+  end
+end

data/lib/switcher/adapters/object.rb

@@ -0,0 +1,65 @@
+module Switcher
+  module Object
+    module Initializer
+      def new(*args, &block)
+        instance = allocate
+        instance.instance_eval { initialize(*args, &block) }
+        instance.class.class_variable_get(:@@__specs__).each do |spc| # TODO - move to something like Switcher.initial_statement(instance)
+          instance.instance_variable_set(:"@#{spc.name}_statement", Statement.new(instance, spc))
+        end
+        instance
+      end
+    end
+
+    module ClassMethods
+      def switcher_pre_initialize(inst, spec)
+        inst.class_eval do
+          spec_name = spec.name
+
+          define_method(:"#{spec_name}_spec") { spec }
+          define_method(:"#{spec_name}_prev") { self.instance_variable_get(:"@#{spec_name}_statement").state_prev }
+
+          define_method(:"#{spec_name}") { self.instance_variable_get(:"@#{spec_name}_statement").state_current }
+
+          events = []
+
+          spec.states.each_pair do |state_name, state|
+            define_method(:"#{spec_name}_#{state_name}?") do
+              state_name == self.send(:"#{spec_name}")
+            end
+
+            events << state.event_names
+          end
+
+          events.flatten.each do |event_name|
+            define_method(:"can_#{event_name}?") do
+              self.class.class_variable_get(:@@__specs__).map { |spc|
+                spc.states[self.send(:"#{spc.name}")].event_names.include?(event_name)
+              }.include?(true)
+            end
+
+            define_method(:"#{event_name}!") do |*args|
+              switch(event_name, *args)
+            end
+          end
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend Switcher::ClassMethods
+      base.extend Switcher::Object::Initializer
+      base.extend Switcher::Object::ClassMethods
+    end
+
+    def switch(event, *args)
+      switch_from(self.class, event, *args)
+    end
+
+    def switch_from(orig, event, *args)
+      self.class.class_variable_get(:@@__specs__).each do |spc|
+        self.instance_variable_get(:"@#{spc.name}_statement").publish(event, orig, args)
+      end
+    end
+  end
+end

data/lib/switcher/facade.rb

@@ -1,15 +1,18 @@
 module Switcher
   class Facade
-    def initialize(data, target_state=nil)
+    def initialize(target, data)
       @args    = data
       @stopped = false
-      @target_state = target_state
+      @bubble_cancelled = false
+      @target_state     = nil
+      @target  = target
     end
 
-    attr_reader :args, :stopped, :target_state
+    attr_reader :args, :stopped, :target, :target_state, :bubble_cancelled
 
     def stop
       @stopped = true
+      @bubble_cancelled = true
     end
 
     alias :restrict :stop
@@ -17,5 +20,9 @@ module Switcher
     def switch_to(state)
       @target_state = state.to_sym
     end
+
+    def cancel_bubble
+      @bubble_cancelled = true
+    end
   end
 end

data/lib/switcher/spec.rb

@@ -7,10 +7,10 @@ module Switcher
       @name        = name.to_sym
       @states      = {}
       @states_list = []
-      @state_prev  = nil
+      @targets     = []
     end
 
-    attr_reader :name, :states, :state_prev
+    attr_reader :name, :states, :states_list, :targets
 
     def state(name, &block)
       listener = Listener.new(name)
@@ -20,26 +20,9 @@ module Switcher
       @states[name.to_sym] = listener
     end
 
-    def current_state
-      @current_state || @states_list.first
+    def notify(*list)
+      @targets = list
     end
 
-    def publish(current_state, event, instance, args)
-      facade = Facade.new(args)
-      ["before_#{event}", event.to_s].each do |ev|
-        @states[current_state.to_sym].trigger(ev, facade, instance, args)
-      end
-      set_state(facade)
-      @states[current_state.to_sym].trigger("after_#{event}", facade, instance, args)
-    end
-
-  private
-
-    def set_state(facade)
-      unless facade.stopped && facade.target_state.nil?
-        @state_prev    = @current_state
-        @current_state = facade.target_state.to_sym
-      end
-    end
   end
 end

data/lib/switcher/statement.rb

@@ -0,0 +1,64 @@
+module Switcher
+  class Statement
+    def initialize(instance, spec, state_current=nil, state_prev=nil)
+      @instance = instance
+
+      @spec = spec
+
+      @state_prev    = state_prev
+      @state_current = state_current
+    end
+
+    attr_reader :name, :states
+
+    def state_current
+      (@state_current || @spec.states_list.first).to_sym
+    end
+
+    def state_prev
+      @state_prev ? @state_prev.to_sym : nil
+    end
+
+    def publish(event, original, args)
+      states = @spec.states
+      state  = state_current
+
+      return unless states.has_key?(state)
+
+      facade = Facade.new(original, args)
+
+      ["before_#{event}", event.to_s].each do |ev|
+        states[state].trigger(ev, facade, @instance, args)
+      end
+
+      set_state(facade)
+
+      states[state].trigger("after_#{event}", facade, @instance, args)
+
+      return if facade.bubble_cancelled
+
+      if @spec.targets.length > 0
+        @spec.targets.each do |target|
+          target_instance = @instance.send(target.to_sym)
+          if target_instance.respond_to?(:each)
+            target_instance.each do |ti|
+              ti.switch_from(original, event, args) if ti.respond_to?(:switch_from)
+            end
+          else
+            target_instance.switch_from(original, event, args) if target_instance.respond_to?(:switch_from)
+          end
+        end
+      end
+    end
+
+  private
+
+    def set_state(facade)
+      unless facade.stopped || facade.target_state.nil?
+        @state_prev    = state_current
+        @state_current = facade.target_state.to_sym
+      end
+    end
+
+  end
+end

data/lib/switcher/version.rb

@@ -1,3 +1,3 @@
 module Switcher
-  VERSION = "0.0.1.beta"
+  VERSION = "0.1.0"
 end

data/lib/switcher.rb

@@ -1,7 +1,20 @@
 require "switcher/version"
+require 'switcher/spec'
+require 'switcher/statement'
+require 'switcher/adapters/object'
+require 'switcher/adapters/active_record'
 
 module Switcher
-  # Your code goes here...
-end
+  module ClassMethods
+    def switcher(name, options={}, &block)
+      self.class_variable_defined?(:@@__specs__) or self.class_variable_set(:@@__specs__, [])
 
-require 'switcher/machine'
+      spec = Spec.new(name, options)
+      spec.instance_eval(&block)
+
+      self.class_variable_get(:@@__specs__) << spec
+
+      switcher_pre_initialize(self, spec)
+    end
+  end
+end

data/spec/fixtures/airbag.rb

@@ -0,0 +1,19 @@
+class Airbag
+  include Switcher::Object
+
+  def initialize
+    @crashed_from = nil
+  end
+
+  attr_reader :crashed_from
+
+  switcher :state do
+    state :idle do
+      on :crash, switch_to: :deployed do |ev|
+        @crashed_from = ev.target
+      end
+    end
+
+    state :deployed
+  end
+end

data/spec/fixtures/box.rb

@@ -0,0 +1,17 @@
+require 'active_record'
+
+class Box < ActiveRecord::Base
+  include Switcher::ActiveRecord
+
+  switcher :state do
+    state :requested do
+      on :produce, switch_to: :produced
+    end
+
+    state :produced do
+      on :break, switch_to: :broken
+    end
+
+    state :broken
+  end
+end

data/spec/fixtures/car.rb

@@ -0,0 +1,37 @@
+class Car
+  include Switcher::Object
+
+  attr_accessor :airbag, :airbags
+
+  switcher :state do
+    notify :airbag, :airbags
+
+    state :new do
+      on :buy, switch_to: :buyed
+    end
+
+    state :buyed do
+      on :start, switch_to: :used
+    end
+
+    state :used do
+      on :crash, switch_to: :damaged do |ev, fast=true|
+        ev.cancel_bubble unless fast
+      end
+    end
+
+    state :damaged do
+      on :repair, switch_to: :used
+    end
+  end
+
+  switcher :movement do
+    state :stands do
+      on :start, switch_to: :moves
+    end
+
+    state :moves do
+      on :stop, switch_to: :stands
+    end
+  end
+end

data/spec/fixtures/human.rb

@@ -1,5 +1,5 @@
 class Human
-  include Switcher::Machine
+  include Switcher::Object
 
   def initialize
     @easy_to_fight = false

data/spec/switcher_active_record_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'active_record'
+require 'fixtures/box'
+require 'fileutils'
+
+describe Switcher::ActiveRecord do
+  before :all do
+    FileUtils.rm("test.sqlite3") if File.exists?("test.sqlite3")
+
+    ActiveRecord::Migration.verbose = false
+    ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => "test.sqlite3")
+
+    ActiveRecord::Schema.define do
+      create_table :boxes do |t|
+        t.string :type
+        t.string :state
+        t.string :state_prev
+      end
+    end
+  end
+
+  after :all do
+    FileUtils.rm("test.sqlite3")
+  end
+
+  let(:box) do
+    Box.new
+  end
+
+  it "should have initial state" do
+    box.state.should eq(:requested)
+  end
+
+  it "should switch states" do
+    box.produce!
+
+    box.state.should eq(:produced)
+  end
+
+  it "should save states" do
+    box.produce!
+    box.save
+
+    box.reload
+
+    box.state.should eq(:produced)
+  end
+
+  it "should save previous states if possible" do
+    box.produce!
+    box.save
+
+    box.reload
+
+    box.state_prev.should eq(:requested)
+  end
+
+  it "should save last defined state" do
+    box.produce!
+    box.break!
+    box.save
+
+    box.reload
+
+    box.state.should eq(:broken)
+  end
+
+  it "can detect possibility to switch" do
+    box.can_produce?.should be_true
+    box.can_break?.should   be_false
+  end
+
+  it "should have state predicate" do
+    box.state_requested?.should be_true
+    box.state_produced?.should  be_false
+  end
+end

data/spec/switcher_spec.rb

@@ -1,54 +1,158 @@
 require 'spec_helper'
 
 require 'fixtures/human'
+require 'fixtures/car'
+require 'fixtures/airbag'
 
 describe Switcher do
 
   describe "Basic functionality" do
-    people = Human.new
+    person = Human.new
+
+    it "should have initial state" do
+      person.state.should eq(:newborn)
+    end
 
     it "should switch to state with option" do
-      people.go_to_school!
-      people.state.should eq(:scholar)
+      person.go_to_school!
+
+      person.state.should eq(:scholar)
     end
 
     it "should switch to state by internal condition" do
-      people.finish_school!(2)
-      people.state.should eq(:worker)
+      person.finish_school!(2)
+
+      person.state.should eq(:worker)
     end
 
     it "should have before and after callbacks" do
-      people.full_age!(100)
-      people.fight!(true)
+      person.full_age!(100)
+      person.fight!(true)
 
-      people.state.should eq(:civil)
-      people.easy_to_fight.should be_true
-      people.honor.should eq(100)
+      person.state.should eq(:civil)
+      person.easy_to_fight.should be_true
+      person.honor.should eq(100)
     end
 
     it "can prevent switch" do
-      people.find_job!(false)
-      people.state.should eq(:civil)
+      person.find_job!(false)
+
+      person.state.should eq(:civil)
     end
 
     it "and can not" do
-      people.find_job!(true)
-      people.state.should eq(:manager)
+      person.switch("find_job", true)
+
+      person.state.should eq(:manager)
     end
 
     it "can detect possibility to switch" do
-      people.can_fight?.should be_false
-      people.can_die?.should   be_true
+      person.can_fight?.should be_false
+      person.can_die?.should   be_true
     end
 
     it "should remember previous state" do
-      people.state_prev.should eq(:civil)
+      person.state_prev.should eq(:civil)
     end
 
     it "should have state predicate" do
-      people.manager?.should be_true
-      people.civil?.should   be_false
+      person.state_manager?.should be_true
+      person.state_civil?.should   be_false
+    end
+  end
+
+  describe "Multiple states" do
+    car = Car.new
+
+    it "should have different states" do
+      car.state.should    eq(:new)
+      car.movement.should eq(:stands)
+    end
+
+    it "should switch states" do
+      car.buy!
+
+      car.state.should    eq(:buyed)
+      car.movement.should eq(:stands)
+    end
+
+    it "should have cross-stated events" do
+      car.start!
+
+      car.state.should    eq(:used)
+      car.movement.should eq(:moves)
+    end
+
+    it "should remember previous states" do
+      car.state_prev.should    eq(:buyed)
+      car.movement_prev.should eq(:stands)
+    end
+
+    it "should have state predicates" do
+      car.state_used?.should be_true
+      car.state_new?.should  be_false
+
+      car.movement_moves?.should  be_true
+      car.movement_stands?.should be_false
     end
   end
 
+  describe "Multiple instances" do
+    car_one = Car.new
+    car_two = Car.new
+
+    it "should work independent" do
+      car_one.buy!
+
+      car_two.state.should eq(:new)
+    end
+  end
+
+  describe "Event bubbling" do
+    it "should bubble event" do
+      car = Car.new
+      car.airbag = Airbag.new
+
+      car.buy!
+      car.start!
+      car.crash!
+
+      car.airbag.state.should eq(:deployed)
+    end
+
+    it "should bubble event to collections" do
+      car = Car.new
+      car.airbags = [Airbag.new, Airbag.new]
+
+      car.buy!
+      car.start!
+      car.crash!
+
+      car.airbags.each do |ab|
+        ab.state.should eq(:deployed)
+      end
+    end
+
+    it "should define original target" do
+      car = Car.new
+      car.airbag = Airbag.new
+
+      car.buy!
+      car.start!
+      car.crash!
+
+      car.airbag.crashed_from.to_s.should eq("Car")
+    end
+
+    it "should cancel bubble" do
+      car = Car.new
+      car.airbag = Airbag.new
+
+      car.buy!
+      car.start!
+      car.crash!(false)
+
+      car.airbag.state.should eq(:idle)
+    end
+  end
 end

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: switcher
 version: !ruby/object:Gem::Version
-  version: 0.0.1.beta
-  prerelease: 6
+  version: 0.1.0
+  prerelease: 
 platform: ruby
 authors:
 - Andrey Savchenko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-28 00:00:00.000000000Z
+date: 2012-03-04 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70269386935900 !ruby/object:Gem::Requirement
+  requirement: &70251275731280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70269386935900
+  version_requirements: *70251275731280
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70269386935320 !ruby/object:Gem::Requirement
+  requirement: &70251275730860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70269386935320
+  version_requirements: *70251275730860
 description: Switcher is simple, event-driven state machine
 email:
 - andrey@aejis.eu
@@ -42,16 +42,23 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- Guardfile
 - README.md
 - Rakefile
 - lib/switcher.rb
+- lib/switcher/adapters/active_record.rb
+- lib/switcher/adapters/object.rb
 - lib/switcher/facade.rb
 - lib/switcher/listener.rb
-- lib/switcher/machine.rb
 - lib/switcher/spec.rb
+- lib/switcher/statement.rb
 - lib/switcher/version.rb
+- spec/fixtures/airbag.rb
+- spec/fixtures/box.rb
+- spec/fixtures/car.rb
 - spec/fixtures/human.rb
 - spec/spec_helper.rb
+- spec/switcher_active_record_spec.rb
 - spec/switcher_spec.rb
 - switcher.gemspec
 homepage: https://github.com/Ptico/switcher
@@ -69,9 +76,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: switcher
 rubygems_version: 1.8.6
@@ -79,6 +86,10 @@ signing_key:
 specification_version: 3
 summary: Switcher is simple, event-driven state machine
 test_files:
+- spec/fixtures/airbag.rb
+- spec/fixtures/box.rb
+- spec/fixtures/car.rb
 - spec/fixtures/human.rb
 - spec/spec_helper.rb
+- spec/switcher_active_record_spec.rb
 - spec/switcher_spec.rb

data/lib/switcher/machine.rb

@@ -1,43 +0,0 @@
-require 'switcher/spec'
-
-module Switcher
-  module Machine
-
-    module ClassMethods
-      def switcher(name, options={}, &block)
-        self.class_variable_defined?(:@@__specs__) or self.class_variable_set(:@@__specs__, [])
-
-        spec = Spec.new(name, options)
-        spec.instance_eval(&block)
-
-        self.class_variable_get(:@@__specs__) << spec # dup and destroy?
-
-        self.class_eval do
-          define_method(:"#{spec.name}_spec") { spec }
-          define_method(:"#{spec.name}_prev") { spec.state_prev }
-
-          define_method(:"#{spec.name}") { spec.current_state }
-
-          events = []
-
-          spec.states.each_pair do |state_name, state|
-            define_method(:"#{state_name}?") { state_name == self.send(:"#{spec.name}") }
-
-            events << state.event_names
-          end
-
-          events.flatten.each do |event_name|
-            define_method(:"can_#{event_name}?") { spec.states[self.send(:"#{spec.name}")].event_names.include?(event_name) }
-            define_method(:"#{event_name}!") do |*args|
-              spec.publish(self.send(:"#{spec.name}"), event_name, self, args)
-            end
-          end
-        end
-      end
-    end
-
-    def self.included(base)
-      base.extend ClassMethods
-    end
-  end
-end