stateful 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9261a6a19bbd004baeacff1e9d6b3d33e3096a8c
-  data.tar.gz: 7c4edb733fb8d48880f3cc89538b200c84a69d8c
+  metadata.gz: 43a52ed260948a8b25ab8e179b6cc1a4279243b8
+  data.tar.gz: 0099bcace08e9525183ff80bb81b4f8b3b32d6ee
 SHA512:
-  metadata.gz: 1a2144835b0991988cc9935bdf70891662552774cda5f9f3d124e4ef6887aabee2d542dbee377f871fb76a500241b546e773b62b1a112b74f47da46623f03130
-  data.tar.gz: 13aaa3bcbe79a07d9d8ceae4eaf58c4e789351ce981e9c9fe639d119489deffa20fd906fdaa137334545930014351d2cd0d97d2e365090342976e10a010f02a2
+  metadata.gz: 01255d072732c11031920c57d6fbadc3c9242329ae4cb7ab4d07239e0a7cb2cebefa34cb7eedd7d4c73ed109764a14f64eb98300acbc34447a818383dce33009
+  data.tar.gz: ac27cc34184bbc0cd40676fd2cf1c198b61630080f2d6bd472bd2b30cdf7cdbee4dfe651df688e033d96cbf1085c3dd8326ef85107ab154bcc1ac936d3fea273

data/lib/stateful/mongoid.rb

@@ -1,26 +1,39 @@
 module Stateful
-  module Mongoid
+  module MongoidIntegration
     extend ActiveSupport::Concern
 
     module ClassMethods
       protected
 
       def define_state_attribute(options)
-        field :state, type: Symbol, default: options[:default]
-        validates_inclusion_of :state,
-                               in: state_infos.keys,
-                               message: options.has_key?(:message) ? options[:message] : 'invalid state value',
+        field options[:name].to_sym, type: Symbol, default: options[:default]
+        validates_inclusion_of options[:name].to_sym,
+                               in: __send__("#{options[:name]}_infos").keys,
+                               message:  options.has_key?(:message) ? options[:message] : "has invalid value",
                                allow_nil: !!options[:allow_nil]
 
         # configure scopes to query the attribute value
-        state_infos.values.each do |info|
+        __send__("#{options[:name]}_infos").values.each do |info|
           states = info.collect_child_states
+          scope_name = "#{options[:prefix]}#{info.name}"
           if states.length == 1
-            scope info.name, where(state: states.first)
+            scope scope_name, where(options[:name] => states.first)
           else
-            scope info.name, where(:state.in => states)
+            scope scope_name, where(options[:name].to_sym.in => states)
           end
         end
+
+        # provide a previous_state helper since mongoid provides the state_change method for us
+        define_method "previous_#{options[:name]}" do
+          changes = __send__("#{options[:name]}_change")
+          changes.first if changes and changes.any?
+        end
+
+        define_method "previous_#{options[:name]}_info" do
+          state = __send__("previous_#{options[:name]}")
+          self.class.__send__("#{options[:name]}_infos")[state] if state
+        end
+
       end
     end
   end

data/lib/stateful/state_info.rb

@@ -1,7 +1,8 @@
 module Stateful
   class StateInfo
     attr_reader :parent, :children, :name, :to_transitions
-    def initialize(state_class, parent, name, config)
+    def initialize(state_class, attr_name, parent, name, config)
+      @attr_name = attr_name
       @state_class = state_class
       if parent
         @parent = parent
@@ -20,15 +21,19 @@ module Stateful
     end
 
     def is?(state)
-      (@name == state or (parent and parent.is?(state)))
+      !!(@name == state or (parent and parent.is?(state)))
     end
 
     def is_group?
       !!@groupConfig
     end
 
+    def infos
+      @state_class.__send__("#{@attr_name}_infos")
+    end
+
     def can_transition_to?(state)
-      state_info = @state_class.state_infos[state]
+      state_info = infos[state]
       if is_group? or state_info.nil? or state_info.is_group?
         false
       else
@@ -43,7 +48,7 @@ module Stateful
     def expand_to_transitions
       if to_transitions.any?
         @to_transitions = to_transitions.flat_map do |to|
-          info = @state_class.state_infos[to]
+          info = infos[to]
 
           if info.is_group?
             info.collect_child_states

data/lib/stateful/version.rb

@@ -1,3 +1,3 @@
 module Stateful
-  VERSION = "0.0.2"
+  VERSION = "0.0.4"
 end

data/lib/stateful.rb

@@ -9,42 +9,52 @@ module Stateful
     if defined?(Mongoid)
       require 'mongoid/document'
       require 'stateful/mongoid'
-      include Stateful::Mongoid if included_modules.include?(::Mongoid::Document)
+      include Stateful::MongoidIntegration if included_modules.include?(::Mongoid::Document)
     end
   end
 
   module ClassMethods
-    def state_infos
-      @state_infos ||= {}
-    end
 
-    def stateful(options)
+    def stateful(name, options = nil)
+      if name.is_a?(Hash)
+        options = name
+        name = options[:name] || :state
+      end
+
+      options[:name] = name
+
       options[:events] ||= []
+      options[:prefix] = name == :state ? '' : "#{name}_"
+
+      # define the method that will contain the info objects.
+      # we use instance_eval here because its easier to implement the ||= {} logic this way.
+      instance_eval "def #{name}_infos; @#{name}_infos ||= {}; end"
 
-      define_method 'state_events' do
+      define_method "#{name}_events" do
         options[:events]
       end
 
-      define_method 'state_info' do
-        self.class.state_infos[self.state]
+      define_method "#{name}_info" do
+        self.class.__send__("#{name}_infos")[__send__(name)]
       end
 
-      define_method 'state_valid?' do
-        self.class.state_infos.keys.include?(state)
+      define_method "#{name}_valid?" do
+        self.class.__send__("#{name}_infos").keys.include?(__send__(name))
       end
 
-      define_method 'change_state' do |new_state, options = {}, &block|
-        return false if new_state == state
-        return false unless state_info.can_transition_to?(new_state)
-        _change_state(new_state, options, [:persist_state, :save], &block)
+      define_method "change_#{name}" do |new_state, options = {}, &block|
+        return false if new_state == __send__(name)
+        return false unless __send__("#{name}_info").can_transition_to?(new_state)
+        __send__("_change_#{name}", new_state, options, [:persist_state, :save], &block)
       end
 
-      define_method 'change_state!' do |new_state, options = {}, &block|
-        raise "transition from #{state} to #{new_state} not allowed" unless state_info.can_transition_to?(new_state)
-        _change_state(new_state, options, [:persist_state!, :save!], &block)
+      define_method "change_#{name}!" do |new_state, options = {}, &block|
+        current_info = __send__("#{name}_info")
+        raise "transition from #{send(name)} to #{new_state} not allowed for #{name}" unless current_info.can_transition_to?(new_state)
+        __send__("_change_#{name}", new_state, options, [:persist_state!, :save!], &block)
       end
 
-      define_method '_change_state' do |new_state, options, persist_methods, &block|
+      define_method "_change_#{name}" do |new_state, options, persist_methods, &block|
         # convert shortcut event name to options hash
         options = {event: options} if options.is_a? Symbol
 
@@ -55,51 +65,48 @@ module Stateful
         #  options[:event] = calling_method if state_events.include? calling_method
         #end
 
-        if block and block.call == false
-          false
-        else
-          callbacks = [:state_change]
-          callbacks << options[:event] if options[:event]
-          run_callbacks *callbacks do
-            self.state = new_state
-
-            ## if a specific persist method value was provided
-            #if options.has_key?(:persist_method)
-            #  # call the method if one was provided
-            #  __send__(options[:persist_method]) if options[:persist_method]
-            ## if no persist method option was provided than use the defaults
-            #else
-              method = persist_methods.find {|m| respond_to?(m)}
-              __send__(method) if method
-            #end
+        callbacks = ["#{name}_change".to_sym]
+        callbacks << options[:event] if options[:event]
+        run_callbacks *callbacks do
+          __send__("#{name}=", new_state)
+          block.call if block
+
+          ## if a specific persist method value was provided
+          if options.has_key?(:persist_method)
+            # call the method if one was provided
+            __send__(options[:persist_method]) if options[:persist_method]
+          # if no persist method option was provided than use the defaults
+          else
+            method = persist_methods.find {|m| respond_to?(m)}
+            __send__(method) if method
           end
-          true
         end
+        true
       end
 
-      protected :change_state
-      protected :change_state!
+      protected "change_#{name}"
+      protected "change_#{name}!"
       private :_change_state
 
-      define_method 'can_transition_to?' do |new_state|
-        state_info.can_transition_to?(new_state)
+      define_method "can_transition_to_#{name}?" do |new_state|
+        __send__("#{name}_info").can_transition_to?(new_state)
       end
 
       # init and configure state info
-      init_state_info(options[:states])
-      state_infos.values.each do |info|
+      init_state_info(name, options[:states])
+      __send__("#{name}_infos").values.each do |info|
         info.expand_to_transitions
 
-        define_method "#{info.name}?" do
-          info.is?(self.state)
+        define_method "#{options[:prefix]}#{info.name}?" do
+          current_info = __send__("#{name}_info")
+          !!(current_info && current_info.is?(info.name))
         end
       end
 
-
       define_state_attribute(options)
 
       # define the event callbacks
-      events = ([:state_change] + options[:events])
+      events = (["#{name}_change".to_sym] + options[:events])
       define_callbacks *events
 
       # define callback helpers
@@ -116,21 +123,21 @@ module Stateful
 
     protected
     def define_state_attribute(options)
-      define_method 'state' do
-        instance_variable_get(:@state) || options[:default]
+      define_method options[:name] do
+        instance_variable_get("@#{options[:name]}") || options[:default]
       end
 
-      define_method 'state=' do |val|
-        instance_variable_set(:@state, val)
+      define_method "#{options[:name]}=" do |val|
+        instance_variable_set("@#{options[:name]}", val)
       end
     end
 
     private
 
-    def init_state_info(values, parent = nil)
-      values.each do |name, config|
-        info = state_infos[name] = Stateful::StateInfo.new(self, parent, name, config)
-        init_state_info(config, info) if info.is_group?
+    def init_state_info(name, values, parent = nil)
+      values.each do |state_name, config|
+        info = __send__("#{name}_infos")[state_name] = Stateful::StateInfo.new(self, name, parent, state_name, config)
+        init_state_info(name, config, info) if info.is_group?
       end
     end
   end

data/spec/mongoid_spec.rb

@@ -17,29 +17,71 @@ class Kata
     :approved => :retired,
     :retired => nil
   }
+
+  stateful :merge_status, default: :na, events: [:merge, :approve_merge, :reject_merge], states: {
+    na: :pending,
+    pending: [:approved, :rejected],
+    approved: nil,
+    rejected: :pending
+  }
+
+  def publish
+    change_state(:needs_testing, :publish)
+  end
+
+  def persist_state
+
+  end
 end
 
-describe Stateful::Mongoid do
+describe Stateful::MongoidIntegration do
   let(:kata) {Kata.new}
 
   it 'should support creating a state field' do
     Kata.fields.keys.include?('state').should be_true
   end
 
+  it 'should support callbacks' do
+    kata.publish
+  end
+
   it 'should support validating state values' do
     kata.state.should == :draft
+    kata.merge_status.should == :na
     kata.valid?.should be_true
     kata.state = :invalid
     kata.valid?.should be_false
   end
 
+  it 'should allow states to be set manually' do
+    kata.state = :approved
+    kata.valid?.should be_true
+  end
+
+  it 'should support state boolean helpers' do
+    kata.draft?.should be_true
+    kata.beta?.should be_false
+    kata.state = :needs_testing
+    kata.beta?.should be_true
+  end
+
   it 'should support can_transition_to?' do
-    kata.can_transition_to?(:needs_testing).should be_true
-    kata.can_transition_to?(:retired).should be_false
+    kata.can_transition_to_state?(:needs_testing).should be_true
+    kata.can_transition_to_state?(:retired).should be_false
   end
 
   it 'should create scopes for each state and virtual state' do
     Kata.beta.selector.should == {"state" => {"$in" => [:needs_testing, :needs_approval]}}
     Kata.draft.selector.should == {"state" => :draft}
   end
+
+  it 'should create prefixed scopes for each state and virtual state of custom state fields' do
+    Kata.merge_status_pending.selector.should == {"merge_status" => :pending}
+  end
+
+  it 'should support previous_state' do
+    kata.previous_state.should be_nil
+
+    # cant test after creation right now until mongoid is configured correctly
+  end
 end

data/spec/stateful_spec.rb

@@ -25,6 +25,12 @@ class Kata
                 :retired => nil
             }
 
+  stateful :merge_status, default: :na, events: [:merge, :approve_merge, :reject_merge], states: {
+      na: :pending,
+      pending: [:approved, :rejected],
+      approved: nil,
+      rejected: :pending
+  }
 
   after_state_change do |doc|
     doc.state_changes += 1
@@ -73,25 +79,40 @@ describe Kata do
 
   it 'should support state_infos' do
     Kata.state_infos.should_not be_nil
+    Kata.merge_status_infos.should_not be_nil
   end
 
   it 'should support default state' do
     kata.state.should == :draft
+    kata.merge_status.should == :na
   end
 
   it 'should support state_info' do
     kata.state_info.should_not be_nil
     kata.state_info.name.should == :draft
+
+    # custom names
+    kata.merge_status_info.should_not be_nil
+    kata.merge_status_info.name.should == :na
   end
 
   it 'should support simple boolean helper methods' do
     kata.draft?.should be_true
     kata.published?.should be_false
+    kata.state = :needs_feedback
+    kata.published?.should be_true
+
+    # custom state names
+    kata.merge_status_na?.should be_true
+    kata.merge_status_approved?.should be_false
+    kata.merge_status = :approved
+    kata.merge_status_approved?.should be_true
   end
 
   context 'change_state' do
     it 'should raise error when an invalid transition state is provided' do
       expect{kata.send(:change_state!, :retired)}.to raise_error
+      expect{kata.send(:change_merge_status!, :approved)}.to raise_error
     end
 
     it 'should raise error when a group state is provided' do
@@ -104,6 +125,7 @@ describe Kata do
 
     it 'should support state_valid?' do
       kata.state_valid?.should be_true
+      kata.merge_status_valid?.should be_true
     end
 
     it 'should change the state when a proper state is provided' do
@@ -116,6 +138,11 @@ describe Kata do
       kata.send(:change_state, :needs_approval).should be_true
       kata.send(:change_state, :approved).should be_true
       kata.state.should == :approved
+
+      # custom
+      kata.send(:change_merge_status, :approved).should be_false
+      kata.send(:change_merge_status, :pending).should be_true
+      kata.merge_status.should == :pending
     end
 
     it 'should support calling passed blocks when state is valid' do
@@ -134,6 +161,15 @@ describe Kata do
       kata.publish
       kata.state_changes.should == 1
     end
+
+    it 'should support can_transition_to_state?' do
+      kata.can_transition_to_state?(:needs_feedback).should be_true
+      kata.can_transition_to_state?(:approved).should be_false
+
+      # custom states
+      kata.can_transition_to_merge_status?(:pending).should be_true
+      kata.can_transition_to_merge_status?(:approved).should be_false
+    end
   end
 
   describe Stateful::StateInfo do
@@ -144,6 +180,9 @@ describe Kata do
       Kata.state_infos[:approved].is?(:published).should be_true
       Kata.state_infos[:approved].is?(:beta).should be_false
       Kata.state_infos[:retired].is?(:beta).should be_false
+
+      # custom
+      Kata.merge_status_infos[:na].is?(:na).should be_true
     end
 
     it 'should support expanded to transitions' do
@@ -152,5 +191,12 @@ describe Kata do
 
       Kata.state_infos[:retired].to_transitions.should be_empty
     end
+
+    it 'should support can_transition_to?' do
+      Kata.state_infos[:draft].can_transition_to?(:needs_feedback).should be_true
+      Kata.state_infos[:draft].can_transition_to?(:approved).should be_false
+
+      Kata.merge_status_infos[:na].can_transition_to?(:pending).should be_true
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stateful
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - jake hoffner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-18 00:00:00.000000000 Z
+date: 2013-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport