maintain 0.2.23 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1266039e3c147c59da0d3c94b51b3511516fb0c9
+  data.tar.gz: 5a7da80deea1aa14248e066c485fb1010627ed69
+SHA512:
+  metadata.gz: c7fcc2ef3ef53205dd0ad838da80b5b33c8d6a5b348c05bdc05407ac26e43e768ec518f07731f533f1a3338ec65c49e62f5d5ec2c5f6d530cfd9b8fa07b22911
+  data.tar.gz: 82432c0d707c58d028945a9a03efbf0e42e94a7b22d86b63c454bfd3f4a9d8f602ee2a2176f73482b13fa4d9ae1e46367c534559e39572d055948650f068c81c

data/CHANGES.md

@@ -0,0 +1,34 @@
+## 0.3.0
+* Rails 4 compatibility
+* Ruby 1.9 required as of 0.3
+* Fixed `bang!` methods not saving on the back end
+
+## 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
+  means `to_a` is now a method on @object.maintained_attribute.
+
+## 0.2.20
+* Removed accidental debugging `puts` calls from ActiveRecord backend
+
+## 0.2.19
+* Added :force option to state and aggregate definitions, allowing you
+  to force a method overwrite
+* Added an attribute_name alias to named scopes in the ActiveRecord
+  backend, since Rails 3.1 has eaten up a number of previously
+  usable state names
+
+## 0.2.18
+* Ruby 1.9.2 and Rails 3.1 compatibility updates (no API changes)

data/README.markdown

@@ -23,7 +23,7 @@ state on an attribute:
 class Foo
   extend Maintain
   maintains :state do
-    state :new, :default => true
+    state :new, default: true
     state :old
   end
 end
@@ -45,7 +45,7 @@ But wait! What if you've already defined "new?" on the Foo class? Not to worry,
 
 And when you *want* Maintain to step on your toes? You can add an optionally add:
 
-	state :new, :force => true
+	state :new, force: true
 
 ...and Maintain will make sure your methods get added, even if it overwrites a previous method.
 
@@ -76,7 +76,7 @@ order you want:
 class Foo
   extend Maintain
   maintains :state do
-    state :new, 12, :default => true
+    state :new, 12, default: true
     state :old, 5
   end
 end
@@ -92,8 +92,8 @@ Hooks
 ```ruby
 class Foo < ActiveRecord::Base
   maintains :state do
-    state :active, :enter => :activated
-    state :inactive, :exit => lambda { self.bar.baz! }
+    state :active, enter: :activated
+    state :inactive, exit: lambda { self.bar.baz! }
   end
 
   def activated
@@ -157,7 +157,7 @@ relational database - or you could implement a single bitmask column:
 ```ruby
 class Foo
   extend Maintain
-  maintains :state, :bitmask => true do
+  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.
@@ -186,10 +186,10 @@ You can also set multiple defaults on bitmasks, just in case your defaults invol
 ```ruby
 class Foo
   extend Maintain
-  maintains :state, :bitmask => true do
-    state :new, 1, :default => true
+  maintains :state, bitmask: true do
+    state :new, 1, default: true
     state :old, 2
-    state :borrowed, 3, :default => true
+    state :borrowed, 3, default: true
     state :blue, 4
   end
 end

data/lib/maintain.rb

@@ -3,33 +3,35 @@ $LOAD_PATH.unshift File.join(File.dirname(__FILE__))
 require 'maintain/backend'
 
 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.
+  # 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(:Value, 'maintain/value')
   autoload(:BitmaskValue, 'maintain/bitmask_value')
   autoload(:IntegerValue, 'maintain/integer_value')
 
   # The core class method of Maintain. Basic usage is:
-  # 
+  #
   #   maintain :state do
-  #     state :new, :default => true
-  #     state :expired, :enter => :expire_children
-  #     state :reopened, :exit => lambda { children.each(&:reopen) }
-  #     aggregate :accessible, :as => [:new, :reopened]
+  #     state :new, default: true
+  #     state :expired, enter: :expire_children
+  #     state :reopened, exit: lambda { children.each(&:reopen) }
+  #     aggregate :accessible, as: [:new, :reopened]
   #   end
-  # 
+  #
   # It also supports more complex configuration options, like bitmask columns
   # and integer values (for performance and portability)
-  # 
-  #   maintain :permissions, :bitmask => true do
+  #
+  #   maintain :permissions, bitmask: true do
   #     state :edit, 1
   #     state :delete, 2
   #     state :manage, 3
   #   end
-  # 
-  # This method is aliased as `maintains` with the intention of allowing developers
-  # to code imperatively ("maintain, damn you!") or descriptively ("it maintains, man")
+  #
+  # This method is aliased as `maintains` with the intention of allowing
+  # developers to code imperatively ("maintain, damn you!") or descriptively
+  # ("it maintains, man")
   def maintain(attribute, options = {}, &block)
     options[:back_end] ||= Maintain::Backend.detect(self)
 
@@ -40,19 +42,22 @@ module Maintain
       maintainer.instance_eval(&block)
     end
 
-    # Define our getters and setters - these are the only methods Maintain will stomp
-    # on if you've already defined them. This is because they're how Maintain works.
+    # Define our getters and setters - these are the only methods Maintain will
+    # stomp on if you've already defined them. This is because they're how
+    # Maintain works.
     class_eval <<-EOC, __FILE__
       def #{attribute}=(value)
         # Find the maintainer on this attribute so we can use it to set values.
         maintainer = self.class.maintainers[:#{attribute}]
         changed = #{attribute} != value
+
         # Run the exit hook if we're changing the value
         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.
+        # 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.
         #{attribute}.set_value(value)
 
         # Allow the back end to write values in an ORM-specific way
@@ -60,8 +65,8 @@ module Maintain
           maintainer.back_end.write(self, :#{attribute}, #{attribute}.value)
         end
 
-        # Last but not least, run the enter hooks for the new value - cause that's how
-        # we do.
+        # 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
 
@@ -73,14 +78,21 @@ module Maintain
     class_eval <<-EOC, __FILE__
       class << self
         def maintain_#{attribute}
-          @#{attribute} ||= maintainers[:#{attribute}].states.sort{|a, b| (a[1][:compare_value] || a[1][:value]) <=> (b[1][:compare_value] || b[1][:value]) }.map{|key, value| key == value[:value] ? key : [key, value[:value]]}
+          @#{attribute} ||= maintainers[:#{attribute}].states.sort do |a, b|
+            a_compare = a[1][:compare_value] || a[1][:value]
+            b_compare = b[1][:compare_value] || b[1][:value]
+            a_compare <=> b_compare
+          end.map do |key, value|
+            key == value[:value] ? key : [key, value[:value]]
+          end
         end
         #{"alias :#{attribute} :maintain_#{attribute}" unless respond_to?(attribute)}
       end
     EOC
 
-    # Last! Not least! Save our maintainer directly on this class. We'll use it in our setters (as in above)
-    # and we'll also modify it instead of replacing it outright, so subclasses or mixins can extend functionality
+    # Last! Not least! Save our maintainer directly on this class. We'll use it
+    # in our setters (as in above) 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
   end
@@ -98,10 +110,13 @@ module Maintain
     end
   end
 
-  if File.file?(version_path = File.join(File.dirname(__FILE__), '..', 'VERSION'))
-    VERSION = File.read(version_path).strip
-  else
-    VERSION = '0.2.0'
+  if !const_defined?(:VERSION)
+    version_path = File.join(File.dirname(__FILE__), '..', 'VERSION')
+    if File.file?(version_path)
+      VERSION = File.read(version_path).strip
+    else
+      VERSION = '0.3.0'
+    end
   end
 end
 

data/lib/maintain/backend.rb

@@ -13,16 +13,6 @@ module 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
 
@@ -58,8 +48,8 @@ module Maintain
         end
       end
 
-      # Detect if we've loaded a backend for this class - that means if its ancestors or
-      # parent classes include any of our back-end classes.
+      # Detect if we've loaded a backend for this class - that means if its
+      # ancestors or parent classes include any of our back-end classes.
       def detect(owner)
         ancestors = owner.ancestors.map(&:to_s)
         # While owner does not refer to "Object"

data/lib/maintain/backend/active_record.rb

@@ -3,26 +3,18 @@ module Maintain
     class ActiveRecord < Maintain::Backend::Base
       def aggregate(maintainee, name, attribute, states, options = {})
         # named_scope will handle the array of states as "IN" in SQL
-        state(maintainee, name, attribute, states, options.merge(:dirty => false))
+        state(maintainee, name, attribute, states, options.merge(dirty: false))
       end
 
       def on(maintainee, attribute, event, state, method, options)
         attribute_check = "#{attribute}#{"_was" if event == :exit}_#{state}?"
         hook_method = options[:after] ? :after : :before
-        maintainee.send("#{hook_method}_save", method, :if => lambda {|instance|
+        maintainee.send("#{hook_method}_save", method, if: lambda {|instance|
           if instance.send("#{attribute}_changed?") && instance.send(attribute_check)
             if options[:if]
-              if options[:if].is_a?(Proc)
-                instance.instance_eval(&options[:if])
-              else
-                instance.send(options[:if])
-              end
+              Maintainer.call_method_or_proc(options[:if], instance)
             elsif options[:unless]
-              if options[:unless].is_a?(Proc)
-                !instance.instance_eval(&options[:unless])
-              else
-                !instance.send(options[:unless])
-              end
+              !Maintainer.call_method_or_proc(options[:unless], instance)
             else
               true
             end
@@ -37,11 +29,19 @@ module Maintain
       end
 
       def state(maintainee, name, attribute, value, options = {})
-        options = {:dirty => true}.merge(options)
-        conditions = {:conditions => {attribute => value}}
-        named_scope_method = defined?(::ActiveRecord::VERSION) && ::ActiveRecord::VERSION::STRING >= '3' ? :scope : :named_scope
-        maintainee.send(named_scope_method, name, conditions) if !maintainee.respond_to?(name) || options[:force]
-        maintainee.send(named_scope_method, "#{attribute}_#{name}", conditions)
+        options = {dirty: true}.merge(options)
+        conditions = {conditions: {attribute => value}}
+        version = defined?(::ActiveRecord::VERSION) && ::ActiveRecord::VERSION::STRING
+        force = !maintainee.respond_to?(name) || options[:force]
+        if version && version >= '3'
+          where = "lambda { where(#{conditions[:conditions].inspect}) }"
+          maintainee.class_eval "scope :#{name}, #{where}" if force
+          maintainee.class_eval "scope :#{attribute}_#{name}, #{where}"
+        else
+          maintainee.named_scope(name, conditions)
+          maintainee.named_scope("#{attribute}_#{name}", conditions)
+        end
+
         if options[:dirty]
           maintainee.class_eval <<-dirty_tracker
             def #{attribute}_was_#{name}?

data/lib/maintain/backend/data_mapper.rb

@@ -11,7 +11,7 @@ module Maintain
       end
 
       def state(maintainee, name, attribute, value)
-        conditions = {:conditions => {attribute => value}}
+        conditions = {conditions: {attribute => value}}
         maintainee.class_eval <<-scope
           def self.#{name}
             all(#{conditions.inspect})

data/lib/maintain/bitmask_value.rb

@@ -4,7 +4,9 @@ module Maintain
     include Enumerable
 
     def to_a
-      @state.states.select {|key, options| options[:value] & @value > 0}.map(&:first)
+      @state.states.select do |key, options|
+        options[:value] & @value > 0
+      end.map(&:first)
     end
 
     def each(&block)
@@ -22,7 +24,10 @@ module Maintain
 
     protected
     def bitmask_for(states)
-      Array(states).compact.map{|value| value_for(value) }.compact.sort.inject(0) {|total, mask| total | mask.to_i }
+      bitmask_values = Array(states).compact.map do |value|
+        value_for(value)
+      end.compact.sort
+      bitmask_values.inject(0) {|total, mask| total | mask.to_i }
     end
 
     def compare_value

data/lib/maintain/maintainer.rb

@@ -3,18 +3,31 @@ module Maintain
   class Maintainer
     attr_reader :back_end
 
+    class << self
+      def call_method_or_proc(method, instance)
+        if method.is_a?(Proc)
+          instance.instance_eval(&method)
+        else
+          instance.send(method)
+        end
+      end
+    end
+
     def aggregate(name, conditions, options = {})
       if conditions.is_a?(Hash) && conditions.has_key?(:as)
         options = conditions
         conditions = options[:as]
       end
       aggregates[name] = conditions
-      # Now we're going to add proxies to test for state being in this aggregate. Don't create
-      # this method unless it doesn't exist.
+
+      # Now we're going to add proxies to test for state being in this
+      # aggregate. Don't create this method unless it doesn't 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?
+        # Define it if'n it don't already exist! 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}
@@ -22,9 +35,21 @@ module Maintain
           end
         EOC
       end
+
       # Now define the state
       if back_end
-        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]})
+        conditions = conditions.select { |value| states.has_key?(value) }
+        conditions = conditions.map do |value|
+          if states[value][:value].is_a?(Symbol)
+            states[value][:value].to_s
+          else
+            states[value][:value]
+          end
+        end
+        conditions = conditions.compact
+        back_end.aggregate(maintainee, name, @attribute, conditions, {
+          force: options[:force]
+        })
       end
     end
 
@@ -57,11 +82,16 @@ module Maintain
     end
 
     def hook(event, state, instance)
-      if state && state.to_s.strip != '' && hooks[state.to_sym] && hook_definitions = hooks[state.to_sym][event.to_sym]
+      if state && state.to_s.strip != '' && hooks[state.to_sym]
+        hook_definitions = hooks[state.to_sym][event.to_sym] || []
         hook_definitions.each do |hook_definition|
-          next if hook_definition[:if] && !call_method_or_proc_on_instance(hook_definition[:if], instance)
-          next if hook_definition[:unless] && call_method_or_proc_on_instance(hook_definition[:unless], instance)
-          call_method_or_proc_on_instance(hook_definition[:method], instance)
+          if hook_definition[:if]
+            next unless call_method_or_proc(hook_definition[:if], instance)
+          end
+          if hook_definition[:unless]
+            next if call_method_or_proc(hook_definition[:unless], instance)
+          end
+          call_method_or_proc(hook_definition[:method], instance)
         end
       end
     end
@@ -86,7 +116,7 @@ module Maintain
     end
 
     def on(*args, &block)
-      options = {:when => :before}.merge(args.last.is_a?(Hash) ? args.pop : {})
+      options = {when: :before}.merge(args.last.is_a?(Hash) ? args.pop : {})
       event, state = args.shift, args.shift
       method = args.shift
       if block_given?
@@ -97,7 +127,7 @@ module Maintain
       else
         hooks[state.to_sym] ||= {}
         hooks[state.to_sym][event.to_sym] ||= []
-        method_hash = {:method => method}.merge(options)
+        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
@@ -127,14 +157,15 @@ module Maintain
         integer(true)
       end
       value ||= name
-      states[name] = {:compare_value => !bitmask? && value.is_a?(Integer) ? value : @increment, :value => value}
+      states[name] = {compare_value: !bitmask? && value.is_a?(Integer) ? value : @increment, value: value}
       @increment += 1
       if back_end
-        back_end.state maintainee, name, @attribute, value.is_a?(Symbol) ? value.to_s : value, :force => options[:force]
+        back_end.state maintainee, name, @attribute, value.is_a?(Symbol) ? value.to_s : value, force: options[:force]
       end
 
-      # We need the states hash to contain the compare_value for this guy before we can set defaults on the bitmask,
-      # since the default should actually be a bitmask of all possible default states
+      # We need the states hash to contain the compare_value for this guy
+      # before we can set defaults on the bitmask, since the default should
+      # actually be a bitmask of all possible default states
       if options.has_key?(:default)
         default(name)
       end
@@ -147,26 +178,27 @@ module Maintain
         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.
+      # Now we're going tests for state. Shortcuts to these methods only get
+      # added if a method of their name doesn't already exist.
       boolean_method = "#{name}?"
-      # Override any attribute_state? methods, because those we need for hooks...
+      shortcut = options[:force] || method_free?(boolean_method)
       maintainee.class_eval <<-EOC
         def #{@attribute}_#{boolean_method}
-          #{@attribute}.#{boolean_method}
+          #{@attribute} == #{value.inspect}
         end
-        #{"alias :#{boolean_method} :#{@attribute}_#{boolean_method}" if method_free?(boolean_method) || options[:force]}
+        #{"alias :#{boolean_method} :#{@attribute}_#{boolean_method}" if shortcut}
       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.
+      # 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
+      shortcut = options[:force] || method_free?(bang_method)
       maintainee.class_eval <<-EOC
         def #{@attribute}_#{bang_method}
-          #{@attribute}.#{bang_method}
+          self.#{@attribute} = #{value.inspect}
         end
-        #{"alias :#{bang_method} :#{@attribute}_#{bang_method}" if method_free?(bang_method) || options[:force]}
+        #{"alias :#{bang_method} :#{@attribute}_#{bang_method}" if shortcut}
       EOC
     end
 
@@ -175,7 +207,10 @@ module Maintain
     end
 
     def value(instance, initial = nil)
-      initial = (back_end && back_end.read(instance, @attribute)) || initial || @default
+      if back_end
+        initial = back_end.read(instance, @attribute)
+      end
+      initial ||= initial || @default
       if bitmask?
         BitmaskValue.new(self, initial || 0)
       elsif integer?
@@ -198,17 +233,14 @@ module Maintain
       # Ugly hack so we don't fetch it 100 times for no reason
       maintainee_class = maintainee
       if class_method
-        respond_to = maintainee_class.respond_to?(method_name)
-        methods = maintainee_class.public_methods + maintainee_class.private_methods + maintainee_class.protected_methods
+        return false if maintainee_class.respond_to?(method_name)
+        methods = maintainee_class.public_methods
+        methods += maintainee_class.private_methods
+        methods += maintainee_class.protected_methods
       else
-        respond_to = false
         methods = maintainee_class.instance_methods
-        # methods = %w(instance_methods public_instance_methods private_instance_methods protected_instance_methods).inject([]) do |methods, method|
-        #   methods + maintainee_class.send(method)
-        # end.uniq
       end
-      # Ruby 1.8 returns arrays of strings; ruby 1.9 returns arrays of symbols. "Awesome."
-      !respond_to && !methods.include?(method_name) && !methods.include?(method_name.to_sym)
+      !methods.include?(method_name.to_sym)
     end
 
     def method_missing(method, *args)
@@ -220,12 +252,8 @@ module Maintain
     end
 
     private
-    def call_method_or_proc_on_instance(method, instance)
-      if method.is_a?(Proc)
-        instance.instance_eval(&method)
-      else
-        instance.send(method)
-      end
+    def call_method_or_proc(method, instance)
+      self.class.call_method_or_proc(method, instance)
     end
   end
-end
+end