maintain 0.1.9 → 0.2.1

data/.rspec

@@ -0,0 +1 @@
+--colour

data/VERSION

@@ -1 +1 @@
-0.1.9
+0.2.1

data/autotest/discover.rb

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

data/lib/maintain/backend/active_record.rb

@@ -0,0 +1,27 @@
+module Maintain
+  module Backend
+    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)
+      end
+
+      def read(instance, attribute)
+        instance.attributes[attribute.to_s]
+      end
+
+      def state(maintainee, name, attribute, value)
+        conditions = {:conditions => {attribute => value}}
+        if defined?(::ActiveRecord::VERSION) && ::ActiveRecord::VERSION::STRING >= '3'
+          maintainee.scope name, conditions
+        else
+          maintainee.named_scope name, conditions
+        end
+      end
+
+      def write(instance, attribute, value)
+        instance.send(:write_attribute, attribute, value)
+      end
+    end
+  end
+end

data/lib/maintain/backend/base.rb

@@ -0,0 +1,22 @@
+module Maintain
+  module Backend
+    class Base
+      def aggregate(maintainee, attribute, name, options, states)
+        require_method :aggregate
+      end
+
+      def read(instance, attribute)
+        require_method :read
+      end
+
+      def write(instance, attribute, value)
+        require_method :write
+      end
+
+      private
+      def require_method(method_name)
+        raise "You need to implement the ##{method_name} method in #{self.class.name}"
+      end
+    end
+  end
+end

data/lib/maintain/backend.rb

@@ -0,0 +1,35 @@
+require 'maintain/backend/base'
+
+module Maintain
+  module Backend
+    class << self
+      def build(back_end, maintainer)
+        back_end = back_end.split('_').map(&:capitalize).join('')
+        if constants.include? back_end.to_s
+          const_get(back_end.to_sym).new
+        else
+          begin
+            back_end = const_missing(back_end)
+            back_end.new
+          rescue
+          end
+        end
+      end
+
+      def const_missing(constant)
+        underscore_constant = constant.to_s.dup
+        underscore_constant.gsub!(/::/, '/')
+        underscore_constant.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        underscore_constant.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        underscore_constant.tr!("-", "_")
+        underscore_constant.downcase!
+        begin
+          require("maintain/backend/#{underscore_constant}")
+          const_get(constant)
+        rescue
+          super
+        end
+      end
+    end
+  end
+end

data/lib/maintain/maintainer.rb

@@ -1,6 +1,8 @@
 # encoding: UTF-8
 module Maintain
   class Maintainer
+    attr_reader :back_end
+
     def aggregate(name, options)
       if options.is_a?(Hash) && options.has_key?(:as)
         options = options[:as]
@@ -20,13 +22,8 @@ module Maintain
         EOC
       end
       # Now define the state
-      if @active_record && method_free?(name, true)
-        conditions = {:conditions => {@attribute => options.map{|value| states[value][:value].is_a?(Symbol) ? states[value][:value].to_s : states[value][:value] }}}
-        if defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::STRING >= "3"
-          maintainee.scope name, conditions
-        else
-          maintainee.named_scope name, conditions
-        end
+      if back_end && method_free?(name, true)
+        back_end.aggregate(maintainee, name, @attribute, options.map{|value| states[value][:value].is_a?(Symbol) ? states[value][:value].to_s : states[value][:value] })
       end
     end
 
@@ -42,8 +39,12 @@ module Maintain
       !!@bitmask
     end
 
-    def default(state)
-      @default = state
+    def default(state = nil)
+      if state
+        @default = state
+      else
+        @default
+      end
     end
 
     def default?
@@ -60,10 +61,12 @@ module Maintain
       end
     end
 
-    def initialize(maintainee, attribute, active_record = false, options = {})
+    def initialize(maintainee, attribute, options = {})
       @maintainee = maintainee.name
       @attribute = attribute.to_sym
-      @active_record = !!active_record
+      if back_end = options.delete(:back_end)
+        @back_end = Maintain::Backend.build(back_end, self)
+      end
       options.each do |key, value|
         self.send(key, value)
       end
@@ -120,13 +123,8 @@ module Maintain
       value ||= name
       states[name] = {:compare_value => !bitmask? && value.is_a?(Integer) ? value : @increment, :value => value}
       @increment += 1
-      if @active_record && !maintainee.respond_to?(name)
-        conditions = {:conditions => {@attribute => value.is_a?(Symbol) ? value.to_s : value}}
-        if defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::STRING >= "3"
-          maintainee.scope name, conditions
-        else
-          maintainee.named_scope name, conditions
-        end
+      if !maintainee.respond_to?(name) && back_end
+        back_end.state maintainee, name, @attribute, value.is_a?(Symbol) ? value.to_s : value
       end
 
       # Now we're going to add proxies to test for state. These methods only get added if a
@@ -148,13 +146,14 @@ module Maintain
       @states ||= {}
     end
 
-    def value(initial = nil)
+    def value(instance, initial = nil)
+      initial = (back_end && back_end.read(instance, @attribute)) || initial || @default
       if bitmask?
-        BitmaskValue.new(self, initial || @default || 0)
+        BitmaskValue.new(self, initial || 0)
       elsif integer?
-        IntegerValue.new(self, initial || @default)
+        IntegerValue.new(self, initial)
       else
-        Value.new(self, initial || @default)
+        Value.new(self, initial)
       end
     end
 
@@ -164,7 +163,7 @@ module Maintain
     end
 
     def maintainee
-      @maintainee.split('::').inject(Object) {|mod, const| mod.const_get(const) }
+      @_maintainee ||= @maintainee.split('::').inject(Object) {|mod, const| mod.const_get(const) }
     end
 
     def method_free?(method_name, class_method = false)

data/lib/maintain.rb

@@ -5,6 +5,7 @@ module Maintain
   # We're not really interested in loading anything into memory if we don't need to,
   # so Maintainer, Value, and the Value subclasses are ignored until they're needed.
   autoload(:Maintainer, 'maintain/maintainer')
+  autoload(:Backend, 'maintain/backend')
   autoload(:Value, 'maintain/value')
   autoload(:BitmaskValue, 'maintain/bitmask_value')
   autoload(:IntegerValue, 'maintain/integer_value')
@@ -39,13 +40,12 @@ module Maintain
         active_record = superclass == ActiveRecord::Base
         superclass = superclass.superclass
       end
-    else
-      active_record = false
+      options[:back_end] = 'active_record' if active_record
     end
 
     # Create an instance of the maintainer class. It handles all of the state
     # configuration, hooking, aggregation, named_scoping, etc.
-    maintainer = Maintainer.new(self, attribute, active_record, options)
+    maintainer = Maintainer.new(self, attribute, options)
     if block_given?
       maintainer.instance_eval(&block)
     end
@@ -54,37 +54,38 @@ module Maintain
     # on if you've already defined them. This is because they're how Maintain works.
     class_eval <<-EOC, __FILE__
       def #{attribute}=(value)
-        # If we can find the maintainer on this attribute, we'll use it to set values.
-        if maintainer = self.class.maintainers[#{attribute.to_sym.inspect}]
+        # Find the maintainer on this attribute so we can use it to set values.
+        if maintainer = self.class.maintainers[:#{attribute}]
+          changed = #{attribute} != value
           # Run the exit hook if we're changing the value
-          maintainer.hook(:exit, #{attribute}.name, self)
+          maintainer.hook(:exit, #{attribute}.name, self) if changed
 
           # Then set the value itself. Maintainer::State will return the value you set,
           # so if we're setting to nil we get rid of the attribute entirely - it's not
           # needed and we want the getter to return nil in that case.
-          # unless 
-          #{attribute}.set_value(value)#{%{
+          #{attribute}.set_value(value)
 
-          # If this is ActiveRecord::Base or a subclass of it, we'll make sure calling the
-          # setter writes a DB-friendly value.
-          write_attribute(#{attribute.to_s.inspect}, @#{attribute} ? @#{attribute}.value.to_s : @#{attribute})
-          } if active_record}
+          # Allow the back end to write values in an ORM-specific way
+          if maintainer.back_end
+            maintainer.back_end.write(self, :#{attribute}, value)
+          end
 
-          # Last but not least, run the enter hooks for the new value - cause that's how we
-          # do.
-          maintainer.hook(:enter, #{attribute}.name, self) if @#{attribute}
-        else
-          # If we can't find a maintainer for this attribute, make our best effort to do what
-          # attr_accessor does - set the instance variable.
-          @#{attribute} = value#{%{
-
-          # ... and on ActiveRecord::Base, we'll also write the attribute like a normal setter.
-          write_attribute(:#{attribute}, @#{attribute})} if active_record}
+          # Last but not least, run the enter hooks for the new value - cause that's how
+          # we do.
+          maintainer.hook(:enter, #{attribute}.name, self) if changed
         end
       end
 
       def #{attribute}
-        @#{attribute} ||= self.class.maintainers[#{attribute.to_sym.inspect}].value#{"(read_attribute(:#{attribute}))" if active_record}
+        if maintainer = self.class.maintainers[:#{attribute}]
+          if @#{attribute}
+            @#{attribute}
+          else
+            @#{attribute} = maintainer.value(self)
+          end
+        else
+          @#{attribute}
+        end
       end
     EOC
 
@@ -92,14 +93,6 @@ module Maintain
     # and we'll also modify it instead of replacing it outright, so subclasses or mixins can extend functionality
     # without replacing it.
     maintainers[attribute.to_sym] = maintainer
-    # 
-    # unless respond_to?(attribute)
-    #   class_eval <<-EOC
-    #     def #{attribute}
-    #       maintainers[#{attribute.to_sym.inspect}]
-    #     end
-    #   EOC
-    # end
   end
   alias :maintains :maintain
 
@@ -110,7 +103,7 @@ module Maintain
   if File.file?(version_path = File.join(File.dirname(__FILE__), '..', 'VERSION'))
     VERSION = File.read(version_path).strip
   else
-    VERSION = '0.0.1'
+    VERSION = '0.2.0'
   end
 end
 

data/maintain.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{maintain}
-  s.version = "0.1.9"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Flip Sasser"]
-  s.date = %q{2010-05-06}
+  s.date = %q{2011-02-03}
   s.description = %q{
       Maintain is a simple state machine mixin for Ruby objects. It supports comparisons, bitmasks,
       and hooks that really work. It can be used for multiple attributes and will always do its best to
@@ -20,47 +20,24 @@ Gem::Specification.new do |s|
     "README.markdown"
   ]
   s.files = [
-    ".gitignore",
-     "README.markdown",
      "Rakefile",
      "VERSION",
      "lib/maintain.rb",
+     "lib/maintain/backend.rb",
+     "lib/maintain/backend/active_record.rb",
+     "lib/maintain/backend/base.rb",
      "lib/maintain/bitmask_value.rb",
      "lib/maintain/integer_value.rb",
      "lib/maintain/maintainer.rb",
      "lib/maintain/value.rb",
-     "maintain.gemspec",
-     "spec/active_record_spec.rb",
-     "spec/aggregates_spec.rb",
-     "spec/bitwise_spec.rb",
-     "spec/comparing_state_spec.rb",
-     "spec/defining_states_spec.rb",
-     "spec/hooks_spec.rb",
-     "spec/integer_spec.rb",
-     "spec/maintain_spec.rb",
-     "spec/object_spec.rb",
-     "spec/proxy_spec.rb",
-     "spec/setting_state_spec.rb",
-     "spec/spec.opts"
+     "maintain.gemspec"
   ]
   s.homepage = %q{http://github.com/flipsasser/maintain}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.6}
   s.summary = %q{A Ruby state machine that lets your code do the driving}
-  s.test_files = [
-    "spec/active_record_spec.rb",
-     "spec/aggregates_spec.rb",
-     "spec/bitwise_spec.rb",
-     "spec/comparing_state_spec.rb",
-     "spec/defining_states_spec.rb",
-     "spec/hooks_spec.rb",
-     "spec/integer_spec.rb",
-     "spec/maintain_spec.rb",
-     "spec/object_spec.rb",
-     "spec/proxy_spec.rb",
-     "spec/setting_state_spec.rb"
-  ]
+  s.test_files = Dir["spec/**/*"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION

data/spec/active_record_spec.rb

@@ -4,7 +4,7 @@
 proceed = false
 begin
   require 'rubygems'
-  gem 'activerecord', '2.3.5'
+  gem 'activerecord', '>= 2.3.5'
   require 'active_record'
   proceed = true
 rescue Gem::LoadError, LoadError

data/spec/data_mapper_spec.rb

@@ -0,0 +1,87 @@
+# # 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'
+#   gem 'datamapper'
+#   require 'datamapper'
+#   proceed = true
+# rescue Gem::LoadError, LoadError
+#   puts 'Not testing DataMapper (unavailable)'
+# end
+# 
+# if proceed = false
+#   # 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, "Datamapper::Resource" 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
+#           state :foo
+#           state :bar
+#           aggregate :everything, :as => [:new, :old, :foo, :bar]
+#           aggregate :fakes, :as => [:foo, :bar]
+#         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
+# 
+#       it "should return the correct name when told to" do
+#         active_maintain_test = ActiveMaintainTest.create(:status => 'old')
+#         ActiveMaintainTest.first.status.name.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 respond_to(:each)
+#       end
+# 
+#       it "should create named_scopes for all aggregates" do
+#         ActiveMaintainTest.should respond_to(:everything)
+#         ActiveMaintainTest.everything.should respond_to(:each)
+#       end
+# 
+#       it "should return the correct collections on aggregates" do
+#         ActiveMaintainTest.destroy_all
+#         one = ActiveMaintainTest.create(:status => :foo)
+#         two = ActiveMaintainTest.create(:status => :bar)
+#         three = ActiveMaintainTest.create(:status => :new)
+#         four = ActiveMaintainTest.create(:status => :old)
+#         ActiveMaintainTest.fakes.should == [one, two]
+#         ActiveMaintainTest.everything.should == [one, two, three, four]
+#       end
+# 
+#     end
+#   end
+# end

data/spec/hooks_spec.rb

@@ -27,7 +27,7 @@ describe Maintain, "hooks" do
       state :new
       state :old
       on :enter, :new, :new_entered
-      on :exit, :old do
+      on :enter, :old do
         self.old_entered
       end
     end
@@ -35,9 +35,8 @@ describe Maintain, "hooks" do
     maintain = MaintainTest.new
     maintain.should_receive(:new_entered)
     maintain.state = :new
-    maintain.should_receive(:old_entered)
+    maintain.should_receive(:old_entered).once
     maintain.state = :old
-    maintain.should_not_receive(:old_entered)
     maintain.state = :old
   end
 

data/spec/integer_spec.rb

@@ -26,6 +26,7 @@ describe Maintain do
 
     it "should return valid names, too" do
       @maintainer.kind = :woman
+      @maintainer.kind.should == 2
       @maintainer.kind.name.should == "woman"
     end
   end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: maintain
 version: !ruby/object:Gem::Version 
+  hash: 21
   prerelease: false
   segments: 
   - 0
+  - 2
   - 1
-  - 9
-  version: 0.1.9
+  version: 0.2.1
 platform: ruby
 authors: 
 - Flip Sasser
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-06 00:00:00 -04:00
+date: 2011-02-03 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -27,11 +28,15 @@ extensions: []
 extra_rdoc_files: 
 - README.markdown
 files: 
-- .gitignore
+- .rspec
 - README.markdown
 - Rakefile
 - VERSION
+- autotest/discover.rb
 - lib/maintain.rb
+- lib/maintain/backend.rb
+- lib/maintain/backend/active_record.rb
+- lib/maintain/backend/base.rb
 - lib/maintain/bitmask_value.rb
 - lib/maintain/integer_value.rb
 - lib/maintain/maintainer.rb
@@ -49,33 +54,38 @@ files:
 - spec/proxy_spec.rb
 - spec/setting_state_spec.rb
 - spec/spec.opts
+- spec/data_mapper_spec.rb
 has_rdoc: true
 homepage: http://github.com/flipsasser/maintain
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: A Ruby state machine that lets your code do the driving
@@ -84,6 +94,7 @@ test_files:
 - spec/aggregates_spec.rb
 - spec/bitwise_spec.rb
 - spec/comparing_state_spec.rb
+- spec/data_mapper_spec.rb
 - spec/defining_states_spec.rb
 - spec/hooks_spec.rb
 - spec/integer_spec.rb

data/.gitignore

@@ -1,2 +0,0 @@
-coverage/
-*.gem