maintain 0.2.21 → 0.2.22

data/CHANGES

@@ -1,3 +1,13 @@
+0.2.22
+  * Added `bang!` method support, so now you can call `@object.awesome!`
+    and its state will be set to "awesome." Like all Maintain methods,
+    I'm saying f*ck you to convention and letting you go nuts; you can
+    achieve the same effect one of three ways:
+    
+    @object.awesome!
+    @object.state.awesome!
+    @object.state_awesome!
+
 0.2.21
   * Added Enumerable support to bitmask values, so now you can parse
     through flags with each, select, map, find, and more! This also

data/README.markdown

@@ -19,88 +19,109 @@ Basic Usage
 **Maintain** is pretty straightforward to use. First, you have to tell a Ruby object to maintain
 state on an attribute:
 
-	class Foo
-	  extend Maintain
-	  maintains :state do
-	    state :new, :default => true
-	    state :old
-	  end
-	end
+```ruby
+class Foo
+  extend Maintain
+  maintains :state do
+    state :new, :default => true
+    state :old
+  end
+end
+```
 
 That's it for basic state maintenance! Check it out:
 
-	foo = Foo.new
-	foo.state			#=> :new
-	foo.new?			#=> true
-	foo.state = :old
-	foo.old?			#=> true
+```ruby
+foo = Foo.new
+foo.state			#=> :new
+foo.new?			#=> true
+foo.state = :old
+foo.old?			#=> true
+```
 
 But wait! What if you've already defined "new?" on the Foo class? Not to worry, Maintain won't step on your toes. Just use:
 
 	foo.state.new?
 
-**UPDATE:** what happens when you *want* Maintain to step on your toes? You can add an optionally add:
+And when you *want* Maintain to step on your toes? You can add an optionally add:
 
 	state :new, :force => true
 
 ...and Maintain will make sure your methods get added, even if it overwrites a previous method.
 
+**UPDATE: Maintain** now supports `bang!` style methods for declaring a state imperatively. It's as simple as calling
+
+```ruby
+foo = Foo.new
+foo.old!
+foo.state #=> :old
+```
+
 Comparisons
 -
 
-**Maintain** provides quick and easy comparisons between states. You can specify integer values of states to compare on,
-or you can just let it infer what it wants. From our example above:
+**Maintain** provides quick and easy comparisons between states. By default, it uses the order in which you add states to
+rank them. From our example above:
 
-	foo.state = :new
-	foo.state > :old	#=> false
-	foo.state <= :old	#=> true
+```ruby
+foo.state = :new
+foo.state > :old	#=> false
+foo.state < :old	#=> true
+```
 
-You could also do:
+As an optional second argument to `state`, you can specify a comparison value. This will allow you to define states in any
+order you want:
 
-	class Foo
-	  extend Maintain
-	  maintains :state do
-	    state :new, 12, :default => true
-	    state :old, 5
-	  end
-	end
+```ruby
+class Foo
+  extend Maintain
+  maintains :state do
+    state :new, 12, :default => true
+    state :old, 5
+  end
+end
 
-	Foo.new.state > old	#=> true
+Foo.new.state > old	#=> true
+```
 
 Hooks
 -
 
 **Maintain** can hook into state entry and exit, and provides a number of mechanisms for doing so:
 
-	class Foo < ActiveRecord::Base
-	  maintains :state do
-	    state :active, :enter => :activated
-	    state :inactive, :exit => lambda { self.bar.baz! }
-	  end
-	
-	  def activated
-	    puts "I'm alive!"
-	  end
-	end
+```ruby
+class Foo < ActiveRecord::Base
+  maintains :state do
+    state :active, :enter => :activated
+    state :inactive, :exit => lambda { self.bar.baz! }
+  end
+
+  def activated
+    puts "I'm alive!"
+  end
+end
+```
 
 Of course, maybe that's not your style. Why not try this?
 
-	class Foo
-	  extend Maintain
-	  maintains :state do
-	    state :active
-	    state :inactive
+```ruby
+class Foo
+  extend Maintain
+  maintains :state do
+    state :active
+    state :inactive
 
-	    on :enter, :active, :activated
-	    on :exit, :inactive do
-	      bar.baz!
-	    end
-	  end
+    on :enter, :active, :activated
+    on :exit, :inactive do
+      bar.baz!
+    end
+  end
 
-	  def activated
-	    puts "I'm alive!"
-	  end
-	end
+  def activated
+    puts "I'm alive!"
+  end
+end
+```
 
 
 Aggregates
@@ -109,21 +130,23 @@ Aggregates
 What about when a group of states is needed? Yeah, you could write `foo.bar? || foo.baz?`. You could even make that a method!
 But why not just add the following?
 
-	class Foo
-	  extend Maintain
-	  maintains :state do
-	    state :new
-	    state :old
-	    state :borrowed
-	    state :blue
-	
-	    aggregate :starts_with_b, [:borrowed, :blue]
-	  end
-	end
-	
-	foo = Foo.new
-	foo.status = :borrowed
-	foo.starts_with_b?		#=> true
+```ruby
+class Foo
+  extend Maintain
+  maintains :state do
+    state :new
+    state :old
+    state :borrowed
+    state :blue
+
+    aggregate :starts_with_b, [:borrowed, :blue]
+  end
+end
+
+foo = Foo.new
+foo.status = :borrowed
+foo.starts_with_b?		#=> true
+```
 
 Bitmasking
 -
@@ -131,48 +154,52 @@ Bitmasking
 Sometimes you need to store a simple combination of values. Sure, you could add individual columns for each value to your
 relational database - or you could implement a single bitmask column:
 
-	class Foo
-	  extend Maintain
-	  maintains :state, :bitmask => true do
-	    # NOTE: Maintain will try to infer a bitmask value if you do not provide an integer here,
-	    # but if you don't -- and you re-order your state calls later -- all stored bitmasks will
-	    # be invalidated. You have been warned.
-	    state :new, 1
-	    state :old, 2
-	    state :borrowed, 3
-	    state :blue, 4
-	  end
-	end
-	
-	foo = Foo.new
-	foo.state 						#=> nil
-	foo.state = [:new, :borrowed]
-	foo.state 						#=> [:new, :borrowed]
-	foo.new? 						#=> true
-	foo.borrowed? 					#=> true
-	foo.blue? 						#=> false
-	foo.blue!
-	foo.blue? 						#=> true
-	
-	# 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
+```ruby
+class Foo
+  extend Maintain
+  maintains :state, :bitmask => true do
+    # NOTE: Maintain will try to infer a bitmask value if you do not provide an integer here,
+    # but if you don't -- and you re-order your state calls later -- all stored bitmasks will
+    # be invalidated. You have been warned.
+    state :new, 1
+    state :old, 2
+    state :borrowed, 3
+    state :blue, 4
   end
-  
-  foo = Foo.new
-  foo.new? 						#=> true
-  foo.old? 						#=> false
-  foo.borrowed? 						#=> true
-  foo.blue? 						#=> false
+end
+
+foo = Foo.new
+foo.state 						#=> nil
+foo.state = [:new, :borrowed]
+foo.state 						#=> [:new, :borrowed]
+foo.new? 						#=> true
+foo.borrowed? 					#=> true
+foo.blue? 						#=> false
+foo.blue!
+foo.blue? 						#=> true
+
+# foo.state will boil happily down to an integer when you store it.
+```
+
+You can also set multiple defaults on bitmasks, just in case your defaults involve some complicated mix of options:
+
+```ruby
+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
 -
@@ -180,12 +207,14 @@ Named Scopes
 **Maintain** knows all about ActiveRecord - it even extends ActiveRecord::Base by default. So it stands to reason that adding states
 and aggregates will automatically create named scopes on ActiveRecord::Base subclasses for those states! Check it:
 
-	class Foo < ActiveRecord::Base
-	  maintains :state do
-	    state :active
-	    state :inactive
-	  end
-	end
-	
-	Foo.active		#=> []
-	Foo.inactive	#=> []
+```ruby
+class Foo < ActiveRecord::Base
+  maintains :state do
+    state :active
+    state :inactive
+  end
+end
+
+Foo.active		#=> []
+Foo.inactive	#=> []
+```

data/Rakefile

@@ -1,25 +1,5 @@
 require 'rake'
 
-task :default => :spec
-
-begin
-  require 'spec/rake/spectask'
-
-  desc "Run all examples"
-  Spec::Rake::SpecTask.new('spec') do |t|
-    t.spec_files = FileList['spec/**/*.rb']
-  end
-
-  desc "Run all examples with RCov"
-  Spec::Rake::SpecTask.new('spec:rcov') do |t|
-    t.spec_files = FileList['spec/**/*.rb']
-    t.rcov = true
-    t.rcov_opts = ['--exclude', 'spec,gem']
-  end
-rescue LoadError
-  puts "Could not load Rspec. To run tests, use `gem install rspec`"
-end
-
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gemspec|

data/VERSION

@@ -1 +1 @@
-0.2.21
+0.2.22

data/autotest/discover.rb

@@ -1,5 +1,4 @@
 require 'autotest/fsevent'
-require 'autotest/growl'
 
 Autotest.add_discovery { "rspec2" }
 

data/lib/maintain/backend.rb

@@ -5,20 +5,24 @@ module Maintain
     class << self
       def add(name, owner)
         classes[name.to_sym] = owner
+        # Dig through the constant name to find if it exists
         modules = owner.split('::')
         if Object.const_defined?(modules.first) && owner = Object.const_get(modules.shift)
           while modules.length > 0
             owner = owner.const_get(modules.shift)
           end
-          if owner.is_a? Module
-            owner.class_eval do
-              class << self
-                include Maintain
-              end
-            end
-          else
-            owner.extend Maintain
-          end
+          # If it exists, extend it with Maintain methods automatically
+          owner.extend Maintain
+          # TODO: Try and remember why I did this
+          # if owner.is_a? Module
+          #   owner.class_eval do
+          #     class << self
+          #       include Maintain
+          #     end
+          #   end
+          # else
+          #   owner.extend Maintain
+          # end
         end
       end
 

data/lib/maintain/maintainer.rb

@@ -24,7 +24,7 @@ module Maintain
       end
       # Now define the state
       if back_end
-        back_end.aggregate(maintainee, name, @attribute, conditions.map{|value| states[value][:value].is_a?(Symbol) ? states[value][:value].to_s : states[value][:value] }, {:force => options[:force]})
+        back_end.aggregate(maintainee, name, @attribute, conditions.select{|value| states.has_key?(value) }.map{|value| states[value][:value].is_a?(Symbol) ? states[value][:value].to_s : states[value][:value] }.compact, {:force => options[:force]})
       end
     end
 
@@ -157,6 +157,17 @@ module Maintain
         end
         #{"alias :#{boolean_method} :#{@attribute}_#{boolean_method}" if method_free?(boolean_method) || options[:force]}
       EOC
+
+      # Last but not least, add bang methods to automatically convert to state. Like boolean
+      # methods above, these only get added if they're not already things that are things.
+      bang_method = "#{name}!"
+      # Override any attribute_state! methods
+      maintainee.class_eval <<-EOC
+        def #{@attribute}_#{bang_method}
+          #{@attribute}.#{bang_method}
+        end
+        #{"alias :#{bang_method} :#{@attribute}_#{bang_method}" if method_free?(bang_method) || options[:force]}
+      EOC
     end
 
     def states

data/lib/maintain/value.rb

@@ -78,20 +78,31 @@ module Maintain
 
     # TODO: Sweet god, this is hideous and needs to be cleaned up!
     def method_missing(method, *args)
-      if (method.to_s =~ /^(.+)\?$/)
-        check = $1.to_sym
-        if @state.states.has_key?(check)
+      if (method.to_s =~ /^(.+)(\?|\!)$/)
+        value_name = $1.to_sym
+        if @state.states.has_key?(value_name)
+          case $2
+          when '?'
+            self.class.class_eval <<-EOC
+              def #{method}
+                self == #{value_name.inspect}
+              end
+            EOC
+            # Calling `method` on ourselves fails. Something to do w/subclasses. Meh.
+            return self == value_name
+          when '!'
+            self.class.class_eval <<-EOC
+              def #{method}
+                self.set_value(#{value_name.inspect})
+              end
+            EOC
+            # Calling `method` on ourselves fails. Something to do w/subclasses. Meh.
+            return self.set_value(value_name)
+          end
+        elsif $2 == '?' && aggregates = @state.aggregates[value_name]
           self.class.class_eval <<-EOC
             def #{method}
-              self == #{check.inspect}
-            end
-          EOC
-          # Calling `method` on ourselves fails. Something to do w/subclasses. Meh.
-          return self == check.to_sym
-        elsif aggregates = @state.aggregates[check]
-          self.class.class_eval <<-EOC
-            def #{method}
-              @state.aggregates[#{check.inspect}].include?(@value)
+              @state.aggregates[#{value_name.inspect}].include?(@value)
             end
           EOC
           return aggregates.include?(@value)

data/spec/active_record_spec.rb

@@ -6,7 +6,10 @@ begin
   require 'rubygems'
   gem 'activerecord', '>= 2.3.5'
   require 'active_record'
+  require 'logger'
   proceed = true
+  ActiveRecord::Base.logger = Logger.new(STDOUT)
+  ActiveRecord::Base.logger.level = Logger::Severity::UNKNOWN
 rescue Gem::LoadError, LoadError
   puts 'Not testing ActiveRecord (unavailable)'
 end

data/spec/setting_state_spec.rb

@@ -33,6 +33,15 @@ describe Maintain do
         @maintainer.state = 'nada'
         @maintainer.state.should be_nil
       end
+
+      it "should support a `state!` bang method, too!" do
+        @maintainer.new!
+        @maintainer.state.should == :new
+        @maintainer.overdue!
+        @maintainer.state.should == :overdue
+        @maintainer.closed!
+        @maintainer.state.should == :closed
+      end
     end
 
     describe "integer states" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: maintain
 version: !ruby/object:Gem::Version
-  version: 0.2.21
+  version: 0.2.22
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-20 00:00:00.000000000 Z
+date: 2012-08-10 00:00:00.000000000 Z
 dependencies: []
 description: ! "\n      Maintain is a simple state machine mixin for Ruby objects.
   It supports comparisons, bitmasks,\n      and hooks that really work. It can be
@@ -73,7 +73,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A Ruby state machine that lets your code do the driving