maintain 0.1.0

data/spec/active_record_spec.rb

@@ -0,0 +1,67 @@
+# Some specs to check against ActiveRecord conflicts. Rails tends to blow
+# shit up when you build it outside of Rails. We'll see how this goes...
+
+proceed = false
+begin
+  require 'rubygems'
+  require 'active_record'
+  proceed = true
+rescue LoadError
+  puts 'Not testing ActiveRecord (unavailable)'
+end
+
+if proceed
+  # Use load to have it evaluate the ActiveRecord::Base extension logic again, in the event
+  # that we've already done that with a previous test.
+  load 'lib/maintain.rb'
+  describe Maintain, "ActiveRecord::Base" do
+    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
+            end
+          end
+        end
+
+        ActiveMaintainTest.maintain :status do
+          state :new, :default => true
+          state :old
+          aggregate :everything, :as => [:new, :old]
+        end
+      end
+
+      it "should default to 'new'" do
+        ActiveMaintainTest.new.status.should == 'new'
+        ActiveMaintainTest.new.status.should == :new
+      end
+
+      it "should allow us to update its status to 'old'" do
+        active_maintain_test = ActiveMaintainTest.new(:status => 'old')
+        active_maintain_test.status.should == 'old'
+        lambda {
+          active_maintain_test.save!
+        }.should_not raise_error
+        ActiveMaintainTest.first.status.should == 'old'
+      end
+    end
+
+    describe "named_scopes" do
+      it "should create named_scopes for all states" do
+        ActiveMaintainTest.should respond_to(:old)
+        ActiveMaintainTest.old.should be_instance_of(Array)
+      end
+
+      it "should create named_scopes for all aggregates" do
+        ActiveMaintainTest.should respond_to(:everything)
+        ActiveMaintainTest.everything.should be_instance_of(Array)
+      end
+    end
+  end
+end

data/spec/aggregates_spec.rb

@@ -0,0 +1,35 @@
+# Configuration point number one: setting and configuring states
+
+require 'lib/maintain'
+
+describe Maintain, "aggregates" do
+  before :each do
+    class MaintainTest
+      extend Maintain
+    end
+  end
+
+  it "should allow me to define an aggregate" do
+    lambda {
+      MaintainTest.maintains :state do
+        state :old
+        state :new
+        state :borrowed
+        state :blue
+        aggregate :b_words, [:borrowed, :blue]
+      end
+    }.should_not raise_error
+  end
+
+  it "should create boolean methods" do
+    MaintainTest.new.should respond_to(:b_words?)
+  end
+
+  it "should return true if one of the states is met in the boolean" do
+    maintain = MaintainTest.new
+    maintain.state = :new
+    maintain.b_words?.should be_false
+    maintain.state = :blue
+    maintain.b_words?.should be_true
+  end
+end

data/spec/bitwise_spec.rb

@@ -0,0 +1,83 @@
+# Basic class method specs
+
+require 'lib/maintain'
+
+describe Maintain do
+  before :each do
+    class MaintainTest
+      extend Maintain
+    end
+  end
+
+  describe "bitmask" do
+    before :each do
+      MaintainTest.maintain :permissions, :bitmask => true do
+        state :edit, 1
+        state :delete, 2
+        state :update, 3
+      end
+      @maintainer = MaintainTest.new
+    end
+
+    describe "accessor methods" do
+      it "should default to zero" do
+        maintainer = MaintainTest.new
+        maintainer.permissions.should == 0
+      end
+
+      it "should be able to test values" do
+        maintainer = MaintainTest.new
+        maintainer.permissions = :edit
+        maintainer.permissions.edit?.should be_true
+        maintainer.permissions.delete?.should_not be_true
+        maintainer.permissions = [:update, :delete]
+        maintainer.permissions.edit?.should_not be_true
+        maintainer.permissions.delete?.should be_true
+        maintainer.permissions.update?.should be_true
+      end
+
+      it "should be able to test values directly on the class" do
+        maintainer = MaintainTest.new
+        maintainer.permissions = :edit
+        maintainer.edit?.should be_true
+        maintainer.delete?.should_not be_true
+      end
+
+      it "should not trap every method" do
+        maintainer = MaintainTest.new
+        lambda {
+          maintainer.permissions.foobar?
+        }.should raise_error(NoMethodError)
+      end
+    end
+
+    describe "setter methods" do
+      it "should be able to set values on the whole field" do
+        @maintainer.permissions = :edit
+        @maintainer.permissions.should == [:edit]
+        @maintainer.permissions.should == 2
+      end
+
+      it "should be able to set values as an array" do
+        @maintainer.permissions = [:edit, :delete]
+        @maintainer.permissions.should == 6
+        @maintainer.permissions.should_not == 7
+        @maintainer.permissions.should == [:edit, :delete]
+      end
+
+      it "should be able to set individual bitmask values" do
+        @maintainer.permissions = nil
+        @maintainer.permissions = []
+        @maintainer.permissions.should == 0
+        @maintainer.permissions.edit!
+        @maintainer.permissions.edit?.should be_true
+        @maintainer.permissions.delete?.should_not be_true
+        @maintainer.permissions.update!
+        @maintainer.permissions.edit?.should be_true
+        @maintainer.permissions.edit?.should be_true
+        @maintainer.permissions.delete?.should_not be_true
+        @maintainer.permissions.update?.should be_true
+      end
+    end
+  end
+end

data/spec/comparing_state_spec.rb

@@ -0,0 +1,194 @@
+# Comparing state values
+
+require 'lib/maintain'
+
+describe Maintain do
+  before :each do
+    class MaintainTest
+      attr_accessor :existant_attribute
+      extend Maintain
+    end
+  end
+
+  describe "testing" do
+    describe "string states" do
+      before :each do
+        MaintainTest.maintain :state, :default => :new do
+          state :new
+          state :overdue
+          state :closed
+        end
+        @maintainer = MaintainTest.new
+        @other_maintainer = MaintainTest.new
+      end
+
+      it "equality methods" do
+        @maintainer.state.should == :new
+        @maintainer.state.should == 'new'
+        @maintainer.state.should == 0
+        @maintainer.state.should == MaintainTest.new.state
+        @maintainer.state.should == @other_maintainer.state
+      end
+
+      describe "boolean methods" do
+        describe "on the accessor" do
+          it "should work" 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 trap every method" do
+            maintainer = MaintainTest.new
+            lambda {
+              maintainer.permissions.foobar?
+            }.should raise_error(NoMethodError)
+          end
+        end
+
+        describe "on the class itself" do
+          it "should work, 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
+            class MaintainTestTwo
+              def new?
+                :i_existed_before_you_came_along
+              end
+              extend Maintain
+              maintains :state, :default => :new do
+                state :new
+                state :overdue
+                state :closed
+              end
+            end
+            MaintainTestTwo.new.new?.should == :i_existed_before_you_came_along
+          end
+        end
+      end
+
+      it "greater than method" do
+        MaintainTest.maintain :state, :default => :closed do
+          state :new
+          state :overdue
+          state :closed
+        end
+        @maintainer.state.should be > :overdue
+        @maintainer.state.should be > 'overdue'
+        @maintainer.state.should be > 1
+      end
+
+      it "less than method" do
+        @maintainer.state.should be < :overdue
+        @maintainer.state.should be < 'overdue'
+        @maintainer.state.should be < 1
+      end
+
+      it "greater-than-or-equal-to method" do
+        MaintainTest.maintain :state, :default => :closed do
+          state :new
+          state :overdue
+          state :closed
+        end
+        @maintainer.state.should be >= :overdue
+        @maintainer.state.should be >= 'overdue'
+        @maintainer.state.should be >= 1
+        @maintainer.state.should be >= :closed
+        @maintainer.state.should be >= 'closed'
+        @maintainer.state.should be >= 2
+      end
+
+      it "less-than-or-equal-to method" do
+        MaintainTest.maintain :state, :default => :new do
+          state :new
+          state :overdue
+          state :closed
+        end
+        @maintainer.state.should be <= :overdue
+        @maintainer.state.should be <= 'overdue'
+        @maintainer.state.should be <= 1
+        @maintainer.state.should be <= :new
+        @maintainer.state.should be <= 'new'
+        @maintainer.state.should be <= 0
+      end
+    end
+
+    describe "integer states" do
+      before :each do
+        MaintainTest.maintain :state, :default => :new do
+          state :new, 1
+          state :overdue, 2
+          state :closed, 3
+        end
+        @maintainer = MaintainTest.new
+      end
+
+      it "equality methods" do
+        @maintainer.state.should == :new
+        @maintainer.state.should == 'new'
+        @maintainer.state.should == 1
+        @maintainer.state.should == MaintainTest.new.state
+      end
+
+      it "greater than method" do
+        MaintainTest.maintain :state, :default => :closed do
+          state :new, 1
+          state :overdue, 2
+          state :closed, 3
+        end
+        @maintainer.state.should be > :overdue
+        @maintainer.state.should be > 'overdue'
+        @maintainer.state.should be > 1
+      end
+
+      it "less than method" do
+        @maintainer.state.should be < :overdue
+        @maintainer.state.should be < 'overdue'
+        @maintainer.state.should be < 2
+      end
+
+      it "greater-than-or-equal-to method" do
+        MaintainTest.maintain :state, :default => :closed do
+          state :new, 1
+          state :overdue, 2
+          state :closed, 3
+        end
+        @maintainer.state.should be >= :overdue
+        @maintainer.state.should be >= 'overdue'
+        @maintainer.state.should be >= 2
+        @maintainer.state.should be >= :closed
+        @maintainer.state.should be >= 'closed'
+        @maintainer.state.should be >= 3
+      end
+
+      it "less-than-or-equal-to method" do
+        MaintainTest.maintain :state, :default => :new do
+          state :new, 1
+          state :overdue, 2
+          state :closed, 3
+        end
+        @maintainer.state.should be <= :overdue
+        @maintainer.state.should be <= 'overdue'
+        @maintainer.state.should be <= 2
+        @maintainer.state.should be <= :new
+        @maintainer.state.should be <= 'new'
+        @maintainer.state.should be <= 1
+      end
+    end
+  end
+end

data/spec/defining_states_spec.rb

@@ -0,0 +1,79 @@
+# Configuration point number one: setting and configuring states
+
+require 'lib/maintain'
+
+describe Maintain do
+  before :each do
+    class MaintainTest
+      attr_accessor :existant_attribute
+      extend Maintain
+    end
+  end
+
+  describe "defining states" do
+    it "should be possible" do
+      lambda {
+        MaintainTest.maintain :existant_attribute do
+          state :new
+        end
+      }.should_not raise_error
+      MaintainTest.new.existant_attribute.should be_nil
+    end
+
+    it "should support default values" do
+      MaintainTest.maintain :existant_attribute do
+        state :new, :default => true
+      end
+      MaintainTest.new.existant_attribute.should == :new
+    end
+
+    it "should support integer values" do
+      MaintainTest.maintain :existant_attribute do
+        state :new, 1, :default => true
+      end
+      MaintainTest.new.existant_attribute.should == 1
+    end
+
+    it "should provide accessor methods on the Maintain::Maintainer class for state values" do
+      maintainer = MaintainTest.maintain :permissions, :bitmask => true do
+        state :edit, 1
+        state :delete, 2
+        state :update, 3
+      end
+      maintainer.update.should == 8
+    end
+
+    it "should not trap all methods when providing accessor methods for state values" do
+      maintainer = MaintainTest.maintain :permissions, :bitmask => true do
+        state :edit, 1
+        state :delete, 2
+        state :update, 3
+      end
+      lambda {
+        maintainer.i_probably_dont_exist
+      }.should raise_error(NoMethodError)
+    end
+
+    describe "as bitmask" do
+      it "should calculate a base-2 compatible integer" do
+        maintainer = MaintainTest.maintain :permissions, :bitmask => true do
+          state :edit, 1
+          state :delete, 2
+          state :update, 3
+        end
+        maintainer.update.should == 8
+      end
+
+      it "should auto-increment bitmask column values (but dangerously!)" do
+        maintainer = MaintainTest.maintain :permissions, :bitmask => true do
+          state :edit
+          state :delete
+          state :update
+        end
+        maintainer.edit.should == 1
+        maintainer.delete.should == 2
+        maintainer.update.should == 4
+      end
+    end
+  end
+end

data/spec/hooks_spec.rb

@@ -0,0 +1,44 @@
+# Comparing state values
+
+require 'lib/maintain'
+
+describe Maintain, "hooks" do
+  before :each do
+    class MaintainTest
+      extend Maintain
+    end
+  end
+
+  it "should allow me to hook into entry and exit" do
+    lambda {
+      MaintainTest.maintain :state do
+        state :new, :enter => :new_entered
+        state :old, :enter => :old_entered
+        on :enter, :new, :new_entered
+        on :exit, :old do
+          self.old_entered
+        end
+      end
+    }.should_not raise_error
+  end
+
+  it "should execute hooks when states are entered and exited" do
+    MaintainTest.maintain :state do
+      state :new
+      state :old
+      on :enter, :new, :new_entered
+      on :exit, :old do
+        self.old_entered
+      end
+    end
+
+    maintain = MaintainTest.new
+    maintain.should_receive(:new_entered)
+    maintain.state = :new
+    maintain.should_receive(:old_entered)
+    maintain.state = :old
+    maintain.should_not_receive(:old_entered)
+    maintain.state = :old
+  end
+
+end

data/spec/integer_spec.rb

@@ -0,0 +1,22 @@
+# Basic class method specs
+
+require 'lib/maintain'
+
+describe Maintain do
+  before :each do
+    class MaintainTest
+      extend Maintain
+    end
+  end
+
+  describe "integer" do
+    before :each do
+      MaintainTest.maintain :kind, :integer => true do
+        state :man, 1
+        state :woman, 2
+        state :none, 3
+      end
+      @maintainer = MaintainTest.new
+    end
+  end
+end

data/spec/maintain_spec.rb

@@ -0,0 +1,45 @@
+# Basic class method specs
+
+require 'lib/maintain'
+
+describe Maintain do
+  before :each do
+    class MaintainTest
+      attr_accessor :existant_attribute
+      extend Maintain
+    end
+  end
+
+  # Basic overview / class methods
+  it "should extend things that include it" do
+    MaintainTest.should respond_to(:maintains)
+  end
+
+  it "should alias the maintain method as `maintains`" do
+    MaintainTest.should respond_to(:maintains)
+  end
+
+  it "should accept a block" do
+    lambda {
+      MaintainTest.maintain :non_existant_attribute do
+        
+      end
+    }.should_not raise_error
+  end
+
+  it "should store a reference to all of the defined states in the class" do
+    MaintainTest.maintain :non_existant_attribute
+    MaintainTest.send(:maintainers)[:non_existant_attribute].should be_instance_of(Maintain::Maintainer)
+  end
+
+  it "should define accessors for non-existant attributes" do
+    MaintainTest.maintain :non_existant_attribute
+    MaintainTest.new.should respond_to('non_existant_attribute', 'non_existant_attribute=')
+  end
+
+  it "shouldn't care about existant attributes" do
+    lambda {
+      MaintainTest.maintain :existant_attribute
+    }.should_not raise_error
+  end
+end

data/spec/object_spec.rb

@@ -0,0 +1,7 @@
+describe 'Maintain' do
+  it "should not monkey patch Object" do
+    lambda {
+      require "lib/maintain"
+    }.should_not change(Object, :methods)
+  end
+end

data/spec/proxy_spec.rb

@@ -0,0 +1,124 @@
+# Comparing state values
+
+require 'lib/maintain'
+
+describe Maintain do
+  before :each do
+    class MaintainTest
+      attr_accessor :existant_attribute
+      extend Maintain
+    end
+
+  end
+
+  describe "`class` calls" do
+    it "should return NilClass for states without a value" do
+      MaintainTest.maintain :state do
+        state :new
+        state :overdue
+        state :closed
+      end
+      MaintainTest.new.state.class.should == NilClass
+    end
+
+    it "should return Symbol for states with a string column" do
+      MaintainTest.maintain :state do
+        state :new
+        state :overdue
+        state :closed
+      end
+      maintain_test = MaintainTest.new
+      maintain_test.state = :overdue
+      maintain_test.state.class.should == Symbol
+    end
+
+    it "should return Integer for states with an integer column" do
+      MaintainTest.maintain :state do
+        state :new, 0
+        state :overdue, 1
+        state :closed, 2
+      end
+      maintain_test = MaintainTest.new
+      maintain_test.state = :closed
+      maintain_test.state.class.should == Fixnum
+    end
+  end
+
+  describe "`inspect` calls" do
+    it "should return 'nil' for states without a default" do
+      MaintainTest.maintain :state do
+        state :new
+        state :overdue
+        state :closed
+      end
+      MaintainTest.new.state.inspect.should == 'nil'
+    end
+
+    it "should return ':new' for a state with a default value of :new" do
+      MaintainTest.maintain :state, :default => :new do
+        state :new
+        state :overdue
+        state :closed
+      end
+      MaintainTest.new.state.inspect.should == ':new'
+    end
+
+    it "should return '2' for a state with a default value of :new, 2 and an :integer column" do
+      MaintainTest.maintain :state, :default => :new do
+        state :new, 2
+        state :overdue, 5
+        state :closed, 22
+      end
+      MaintainTest.new.state.inspect.should == '2'
+    end
+  end
+
+  describe "`nil?` calls" do
+    it "should return true for states without a default" do
+      MaintainTest.maintain :state do
+        state :new
+        state :overdue
+        state :closed
+      end
+      MaintainTest.new.state.nil?.should be_true
+    end
+
+    it "should return false for states with a default" do
+      MaintainTest.maintain :state, :default => :new do
+        state :new
+        state :overdue
+        state :closed
+      end
+      MaintainTest.new.state.nil?.should_not be_true
+    end
+  end
+
+  describe "`to_s` calls" do
+    it "should return '' for states without a default" do
+      MaintainTest.maintain :state do
+        state :new
+        state :overdue
+        state :closed
+      end
+      MaintainTest.new.state.to_s.should == ''
+    end
+
+    it "should return 'new' for a state with a default value of :new" do
+      MaintainTest.maintain :state, :default => :new do
+        state :new
+        state :overdue
+        state :closed
+      end
+      MaintainTest.new.state.to_s.should == 'new'
+    end
+
+    it "should return '2' for a state with a default value of :new, 2 and an :integer column" do
+      MaintainTest.maintain :state, :default => :new do
+        state :new, 2
+        state :overdue, 5
+        state :closed, 22
+      end
+      MaintainTest.new.state.to_s.should == '2'
+    end
+  end
+end