maintain 0.2.10 → 0.2.11

data/README.markdown

@@ -150,6 +150,24 @@ relational database - or you could implement a single bitmask column:
 	
 	# foo.state will boil happily down to an integer when you store it.
 
+You can also set multiple defaults on bitmasks, just in case you're defaults involve some complicated mix of options:
+
+  class Foo
+    extend Maintain
+    maintains :state, :bitmask => true do
+      state :new, 1, :default => true
+      state :old, 2
+      state :borrowed, 3, :default => true
+      state :blue, 4
+    end
+  end
+  
+  foo = Foo.new
+  foo.new? 						#=> true
+  foo.old? 						#=> false
+  foo.borrowed? 						#=> true
+  foo.blue? 						#=> false
+
 Named Scopes
 -
 

data/VERSION

@@ -1 +1 @@
-0.2.10
+0.2.11

data/lib/maintain/backend/active_record.rb

@@ -3,20 +3,36 @@ module Maintain
     class ActiveRecord < Maintain::Backend::Base
       def aggregate(maintainee, name, attribute, states)
         # named_scope will handle the array of states as "IN" in SQL
-        state(maintainee, name, attribute, states)
+        state(maintainee, name, attribute, states, false)
+      end
+
+      def on(maintainee, attribute, event, state, method, options)
+        attribute_check = "#{attribute}#{"_was" if event == :exit}_#{state}?"
+        maintainee.before_save method, :if => lambda {|instance|
+          instance.send("#{attribute}_changed?") && instance.send(attribute_check) &&
+            (!options[:if] || (options[:if].is_a?(Proc) && instance.instance_eval(&options[:unless])) || instance.send(options[:if])) &&
+            (!options[:unless] || !(options[:unless].is_a?(Proc) && instance.instance_eval(&options[:unless])) || !instance.send(options[:unless]))
+        }
       end
 
       def read(instance, attribute)
         instance.read_attribute(attribute)
       end
 
-      def state(maintainee, name, attribute, value)
+      def state(maintainee, name, attribute, value, dirty = true)
         conditions = {:conditions => {attribute => value}}
         if defined?(::ActiveRecord::VERSION) && ::ActiveRecord::VERSION::STRING >= '3'
           maintainee.scope name, conditions
         else
           maintainee.named_scope name, conditions
         end
+        if dirty
+          maintainee.class_eval <<-dirty_tracker
+            def #{attribute}_was_#{name}?
+              #{attribute}_was == self.class.maintainers[:#{attribute}].value(self).value_for(:#{name})
+            end
+          dirty_tracker
+        end
       end
 
       def write(instance, attribute, value)

data/lib/maintain/backend/base.rb

@@ -1,10 +1,16 @@
 module Maintain
   module Backend
     class Base
+      attr_reader :maintainer
+
       def aggregate(maintainee, attribute, name, options, states)
         require_method :aggregate
       end
 
+      def initialize(maintainer)
+        @maintainer = maintainer
+      end
+
       def read(instance, attribute)
         require_method :read
       end

data/lib/maintain/backend.rb

@@ -25,11 +25,11 @@ module Maintain
       def build(back_end, maintainer)
         back_end = back_end.to_s.split('_').map(&:capitalize).join('')
         if constants.include? back_end.to_s
-          const_get(back_end.to_sym).new
+          const_get(back_end.to_sym).new(maintainer)
         else
           begin
             back_end = const_missing(back_end)
-            back_end.new
+            back_end.new(maintainer)
           rescue
           end
         end

data/lib/maintain/maintainer.rb

@@ -91,13 +91,17 @@ module Maintain
       if block_given?
         method = block
       end
-      hooks[state.to_sym] ||= {}
-      hooks[state.to_sym][event.to_sym] ||= []
-      method_hash = {:method => method}.merge(options)
-      if old_definition = hooks[state.to_sym][event.to_sym].find{|hook| hook[:method] == method}
-        old_definition.merge!(method_hash)
+      if back_end && back_end.respond_to?(:on)
+        back_end.on(maintainee, @attribute, event, state, method, options)
       else
-        hooks[state.to_sym][event.to_sym].push(method_hash)
+        hooks[state.to_sym] ||= {}
+        hooks[state.to_sym][event.to_sym] ||= []
+        method_hash = {:method => method}.merge(options)
+        if old_definition = hooks[state.to_sym][event.to_sym].find{|hook| hook[:method] == method}
+          old_definition.merge!(method_hash)
+        else
+          hooks[state.to_sym][event.to_sym].push(method_hash)
+        end
       end
     end
 
@@ -134,19 +138,24 @@ module Maintain
         default(name)
       end
 
+      if options.has_key?(:enter)
+        on :enter, name.to_sym, options.delete(:enter)
+      end
+
+      if options.has_key?(:exit)
+        on :exit, name.to_sym, options.delete(:exit)
+      end
+
       # Now we're going to add proxies to test for state. These methods only get added if a
       # method of their name doesn't already exist.
       boolean_method = "#{name}?"
-      if method_free?(boolean_method)
-        # Define it if'n it don't already exit! These are just proxies - so Foo.maintains(:state) { state :awesome }
-        # will now have Foo.new.awesome?. But that's really just a proxy for Foo.new.state.awesome?
-        # So they're just shortcuts for brevity's sake.
-        maintainee.class_eval <<-EOC
-          def #{boolean_method}
-            #{@attribute}.#{boolean_method}
-          end
-        EOC
-      end
+      # Override any attribute_state? methods, because those we need for hooks...
+      maintainee.class_eval <<-EOC
+        def #{@attribute}_#{boolean_method}
+          #{@attribute}.#{boolean_method}
+        end
+        #{"alias :#{boolean_method} :#{@attribute}_#{boolean_method}" if method_free?(boolean_method)}
+      EOC
     end
 
     def states

data/lib/maintain/value.rb

@@ -79,7 +79,7 @@ module Maintain
             end
           EOC
           # Calling `method` on ourselves fails. Something to do w/subclasses. Meh.
-          return self == $1.to_sym
+          return self == check.to_sym
         elsif aggregates = @state.aggregates[check]
           self.class.class_eval <<-EOC
             def #{method}

data/spec/active_record_spec.rb

@@ -19,19 +19,22 @@ if proceed
     it "should automatically be extended" do
       ActiveRecord::Base.should respond_to(:maintain)
     end
-    describe "accessors" do
-      before :each do
-        ActiveRecord::Base.establish_connection({:adapter => 'sqlite3', :database => ':memory:', :pool => 5, :timeout => 5000})
-        class ::ActiveMaintainTest < ActiveRecord::Base; end
-        silence_stream(STDOUT) do
-          ActiveRecord::Schema.define do
-            create_table :active_maintain_tests, :force => true do |t|
-              t.string :status
-              t.integer :permissions
-            end
+
+    before :each do
+      ActiveRecord::Base.establish_connection({:adapter => 'sqlite3', :database => ':memory:', :pool => 5, :timeout => 5000})
+      class ::ActiveMaintainTest < ActiveRecord::Base; end
+      silence_stream(STDOUT) do
+        ActiveRecord::Schema.define do
+          create_table :active_maintain_tests, :force => true do |t|
+            t.string :status
+            t.integer :permissions
           end
         end
+      end
+    end
 
+    describe "accessors" do
+      before :all do
         ActiveMaintainTest.maintain :status do
           state :new, :default => true
           state :old
@@ -75,7 +78,7 @@ if proceed
     end
 
     describe "bitmasks" do
-      before :each do
+      before :all do
         ActiveMaintainTest.maintain :permissions, :bitmask => true do
           state :add, 0
           state :delete, 1
@@ -114,7 +117,67 @@ if proceed
       end
     end
 
+    describe "hooks" do
+      before :all do
+        ActiveMaintainTest.maintain :status do
+          state :new, :default => true
+          state :old
+          state :foo
+          state :bar
+          aggregate :everything, :as => [:new, :old, :foo, :bar]
+          aggregate :fakes, :as => [:foo, :bar]
+
+          on :enter, :old, :do_something
+          on :exit, :foo, :do_something_else
+          
+        end
+
+        ActiveMaintainTest.class_eval do
+          def do_something
+            # Do... something?
+          end
+
+          def do_something_else
+            # Do something else!
+          end
+        end
+      end
+
+      it "should not send hooks immediately on attribute setting" do
+        active_maintain_test = ActiveMaintainTest.new
+        active_maintain_test.should_not_receive(:do_something)
+        active_maintain_test.status = :old
+      end
+
+      it "should send hooks when a record is saved" do
+        active_maintain_test = ActiveMaintainTest.new
+        active_maintain_test.should_receive(:do_something)
+        active_maintain_test.status = :old
+        active_maintain_test.save
+      end
+
+      it "should send :exit hooks when a record is saved after a value is exited from" do
+        active_maintain_test = ActiveMaintainTest.new
+        active_maintain_test.status = :foo
+        active_maintain_test.save
+        active_maintain_test.should_receive(:do_something_else)
+        active_maintain_test.status = :new
+        active_maintain_test.save
+      end
+    end
+
     describe "named_scopes" do
+      before :all do
+        ActiveMaintainTest.maintain :status do
+          state :new, :default => true
+          state :old
+          state :foo
+          state :bar
+          aggregate :everything, :as => [:new, :old, :foo, :bar]
+          aggregate :fakes, :as => [:foo, :bar]
+        end
+      end
+
       it "should create named_scopes for all states" do
         ActiveMaintainTest.should respond_to(:old)
         ActiveMaintainTest.old.should respond_to(:each)

data/spec/bitwise_spec.rb

@@ -19,6 +19,7 @@ describe Maintain do
       @maintainer = MaintainTest.new
       @maintainer.permissions.edit?.should be_true
       @maintainer.permissions.delete?.should be_true
+      @maintainer.permissions.update?.should_not be_true
     end
   end
 

data/spec/comparing_state_spec.rb

@@ -74,9 +74,21 @@ describe Maintain do
               state :closed
             end
             maintainer = MaintainTest.new
-            maintainer.state.new?.should be_true
-            maintainer.state.overdue?.should be_false
-            maintainer.state.closed?.should be_false
+            maintainer.new?.should be_true
+            maintainer.overdue?.should be_false
+            maintainer.closed?.should be_false
+          end
+
+          it "should work with an attribute name prefix, too!" do
+            MaintainTest.maintain :state, :default => :new do
+              state :new
+              state :overdue
+              state :closed
+            end
+            maintainer = MaintainTest.new
+            maintainer.state_new?.should be_true
+            maintainer.state_overdue?.should be_false
+            maintainer.state_closed?.should be_false
           end
 
           it "should not override pre-existing methods" do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: maintain
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 1
   prerelease: 
   segments: 
   - 0
   - 2
-  - 10
-  version: 0.2.10
+  - 11
+  version: 0.2.11
 platform: ruby
 authors: 
 - Flip Sasser
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-03 00:00:00 -04:00
+date: 2011-06-23 00:00:00 -04:00
 default_executable: 
 dependencies: []