app_mode 0.0.4 → 1.0.0

data/README

@@ -30,7 +30,7 @@ There are two ways to use this gem.
 
    See notes below on the :dynamic state, which is the default.
 
-    my_mode = AppMode.new
+    my_mode = StateManager.new
 
     my_mode.state = :test
 
@@ -44,12 +44,12 @@ There are two ways to use this gem.
 
    Or specify the state you want to use when initializing the object:
 
-    my_mode = AppMode.new(:development)
+    my_mode = StateManager.new(:development)
 
    If you would like to use states other than those provided, you are free
    to do so:
 
-    my_mode = AppMode.new(:blue, [:red, :yellow, :green, :blue])
+    my_mode = StateManager.new(:blue, [:red, :yellow, :green, :blue])
 
     my_mode.state = :yellow
 
@@ -59,7 +59,7 @@ There are two ways to use this gem.
 
    The :dynamic state is still valid with custom states:
 
-    my_mode = AppMode.new(:dynamic, [:red, :yellow, :green, :blue])
+    my_mode = StateManager.new(:dynamic, [:red, :yellow, :green, :blue])
 
 2. Use the class methods:
    This method is really only recommended for the end application. The initial
@@ -86,18 +86,18 @@ to your gem or anyone else's.
 The following method is recommended for use in libraries or gems:
 
   module MyModule
-    MyModuleMode = AppMode.new
+    MyModuleMode = StateManager.new
   end
 
 or
 
   class MyClass
-    MyClassMode = AppMode.new
+    MyClassMode = StateManager.new
   end
 
 == A Word on States
 
-* AppMode assumes the following default "states":
+* StateManager assumes the following default "states":
 
   :development
 
@@ -107,20 +107,20 @@ or
 
   :production
 
-* There is a fifth state (:dynamic), which will tell AppMode to determine
+* There is a fifth state (:dynamic), which will tell StateManager to determine
   the state by examining the stack trace. It is only available when initializing
-  a new AppMode object and assumes that the first state is 'development',
+  a new StateManager object and assumes that the first state is 'development',
   the second is 'test', the third is 'rake', and the last one (not the fourth)
   is 'production'. If less than four states are specified, the last one will be
   used for multiple states. For example, if the states specified are
   [:orange, :apple, :grape], :grape will be used for both rake and production.
 
-* Only states in the list when the AppMode object were created are valid.
+* Only states in the list when the StateManager object were created are valid.
   For example, the following code will generate errors:
 
-   my_mode = AppMode.new(:blue, [:red, :green]) #=> RuntimeError: Invalid environment setting: 'blue'.
+   my_mode = StateManager.new(:blue, [:red, :green]) #=> RuntimeError: Invalid environment setting: 'blue'.
 
-   my_mode = AppMode.new(:dynamic, [:red, :green])
+   my_mode = StateManager.new(:dynamic, [:red, :green])
 
    my_mode.state = :development #=> RuntimeError: Invalid environment setting: 'development'.
 
@@ -132,7 +132,7 @@ or
 
   Check for inclusion in the array of valid states:
 
-   my_mode = AppMode.new(:red, [:red, :green])
+   my_mode = StateManager.new(:red, [:red, :green])
 
    if my_mode.valid_states.include?(:purple) && my_mode.purple
      # Purple code.
@@ -140,7 +140,7 @@ or
 
   Use equivalency:
 
-   my_mode = AppMode.new(:red, [:red, :green])
+   my_mode = StateManager.new(:red, [:red, :green])
 
    if my_mode.state == :purple
      # Purple code.
@@ -148,7 +148,7 @@ or
 
 * If you are compelled to change the states for the global AppMode class,
   that may be done by using the setup method, which accepts the same
-  arguments as AppMode.new. Passing in a state of :dynamic will allow it
+  arguments as StateManager.new. Passing in a state of :dynamic will allow it
   to set the state as it is intended.
 
 * Although this document explains how to do so,

data/app_mode.gemspec

@@ -1,8 +1,8 @@
 Gem::Specification.new do |s|
   s.name = 'app_mode'
-  s.version = '0.0.4'
+  s.version = '1.0.0'
 
-  s.summary = 'Application state management.'
+  s.summary = 'State management for objects and applications.'
   s.description = 'AppMode provides state management for ' +
     'modules, classes, libraries, and applications.'
 

data/lib/app_mode/app_mode.rb

@@ -1,5 +1,5 @@
-# This file contains a class to manage information about the mode that the
-# executing code is running in.
+# This file contains a global class to manage information about the mode
+# that the executing code is running in.
 
 #--
 ################################################################################
@@ -34,19 +34,24 @@
 #++
 
 # This class manages the mode that the executing code is running in.
-class AppMode
-  attr_reader :state, :valid_states
-
+class AppMode < StateManager
   # Tracks a global mode setting.
   @@mode = nil
 
+  # Constructor.
+  def initialize(*args)
+    # AppMode.new should not be called.
+    raise NotImplementedError, "#{self.class.name}.new is not implemented. " +
+      "You probably want #{self.class.superclass.name}.new."
+  end
+
   class << self
     # Override the send method.
     #
     # This was implemented to cover the case where test is used as a state.
     # In that case, the default behavior was to call the private
     # test method from Kernel. This prevents that behavior in cases where a
-    # public method is available via method_missing in this class.
+    # public method is available via method_missing in the parent class.
     def send(method, *args)
       return method_missing(method, *args) if respond_to_missing?(method, false)
       super
@@ -54,7 +59,7 @@ class AppMode
 
     # Initializes the global mode setting.
     def setup(*args)
-      @@mode = self.new(*args)
+      @@mode = self.superclass.new(*args)
     end
 
     ########################################################################
@@ -78,107 +83,4 @@ class AppMode
       super
     end
   end
-
-  # Constructor.
-  # ==== Input
-  # [env : Symbol] The environment that the mode should be set to.
-  # [valid_states : Array : (:development, :test, :production)] Valid states.
-  # ==== Notes
-  # <tt>env</tt> must be a member of <tt>states</tt>.
-  # ==== Examples
-  #  AppMode.new                     #=> <AppMode @state=:production, @valid_states=[:development, :test, :production]>
-  #  AppMode.new(:test)              #=> <AppMode @state=:test, @valid_states=[:development, :test, :production]>
-  #  AppMode.new(:dev, [:abc, :dev]) #=> <AppMode @state=:dev, @valid_states=[:abc, :dev]>
-  def initialize(
-      state        = :dynamic,
-      valid_states = [:development, :test, :rake, :production])
-    @state = state
-    @valid_states = valid_states
-    set_state @state
-  end
-
-  # Sets the environment instance variable.
-  # ==== Input
-  # [value : Symbol] The value that will be used for the environment.
-  def state=(value)
-    set_state value
-  end
-
-  # Override the send method.
-  #
-  # This was implemented to cover the case where test is used as a state.
-  # In that case, the default behavior was to call the private
-  # test method from Kernel. This prevents that behavior in cases where a
-  # public method is available via method_missing in this class.
-  def send(method, *args)
-    return method_missing(method, *args) if respond_to_missing?(method, false)
-    super
-  end
-
-  ############################################################################
-  private
-  ############################################################################
-
-  # Returns the appropriate state to use when setting the state dynamically.
-  # ==== Output
-  # [Symbol] The state that should be used when setting the state dynamically.
-  def dynamic_state
-    call = origin
-    return @valid_states[0] unless call.sub(/^\.\//, '').match(/\//)
-
-    case call
-      when /rake_test_loader\.rb/,
-          %r[/tests?/test_\w+?.rb], %r[/tests?/\w+?_test.rb]
-        return @valid_states[1]
-      when %r[/bin/rake]
-        return @valid_states[2]
-    end
-
-    return @valid_states.last
-  end
-
-  # Returns the first call in the stack.
-  # ==== Output
-  # [String] The file that made the first call in the stack.
-  # ==== Notes
-  # This method is overridden during tests.
-  def origin
-    caller.last
-  end
-
-  # Allows the getting of the mode.
-  # ==== Input
-  # [method : Symbol] The method that was called.
-  # [*args : Array] Any arguments that were passed in.
-  # [&block : Block] A block, if specified.
-  def method_missing(method, *args, &block)
-    return method == @state if respond_to_missing?(method, false)
-    super
-  end
-
-  # Ensure that the object knows what it can respond to via method_missing.
-  # ==== Input
-  # [method : Symbol] The method to check for a response to.
-  # [include_private : Boolean] Whether to include private methods.
-  # ==== Output
-  # [Boolean] Indicates whether the object will respond to the specified method.
-  def respond_to_missing?(method, include_private)
-    return true if @valid_states.include?(method)
-    super
-  end
-
-  # Sets the state.
-  # ==== Input
-  # [value : Symbol] The value to use for the state.
-  def set_state(value)
-    unless @valid_states.include?(value) || value == :dynamic
-      raise "Invalid environment setting: '#{value}'."
-    end
-
-    if value == :dynamic
-      @state = dynamic_state || @valid_states.last
-    else
-      @state = value
-    end
-  end
 end

data/lib/app_mode/state_manager.rb

@@ -0,0 +1,147 @@
+# This file contains a class to manage information about the state of
+# a module, class, object, or application.
+
+#--
+################################################################################
+#                      Copyright (C) 2011 Travis Herrick                       #
+################################################################################
+#                                                                              #
+#                                 \v^V,^!v\^/                                  #
+#                                 ~%       %~                                  #
+#                                 {  _   _  }                                  #
+#                                 (  *   -  )                                  #
+#                                 |    /    |                                  #
+#                                  \   _,  /                                   #
+#                                   \__.__/                                    #
+#                                                                              #
+################################################################################
+# This program is free software: you can redistribute it                       #
+# and/or modify it under the terms of the GNU General Public License           #
+# as published by the Free Software Foundation,                                #
+# either version 3 of the License, or (at your option) any later version.      #
+#                                                                              #
+# Commercial licensing may be available for a fee under a different license.   #
+################################################################################
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY;                                                    #
+# without even the implied warranty of MERCHANTABILITY                         #
+# or FITNESS FOR A PARTICULAR PURPOSE.                                         #
+# See the GNU General Public License for more details.                         #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.        #
+################################################################################
+#++
+
+# This class assists in managing the state of
+# a module, class, object, or application.
+class StateManager
+  attr_reader :state, :valid_states
+
+  # Constructor.
+  # ==== Input
+  # [state : Symbol] The state that should be used initially.
+  #
+  #                  :dynamic is a special state that will determine the best
+  #                  state based on the environment that the code is running in.
+  # [valid_states : Array : (:development, :test, :production)] Valid states.
+  # ==== Notes
+  # <tt>env</tt> must be a member of <tt>states</tt>.
+  # ==== Examples
+  #  StateManager.new                     #=> <StateManager @state=:rake, @valid_states=[:development, :test, :rake, :production]>
+  #  StateManager.new(:test)              #=> <StateManager @state=:test, @valid_states=[:development, :test, :rake, :production]>
+  #  StateManager.new(:dev, [:abc, :dev]) #=> <StateManager @state=:dev, @valid_states=[:abc, :dev]>
+  def initialize(
+      state        = :dynamic,
+      valid_states = [:development, :test, :rake, :production])
+    @state = state
+    @valid_states = valid_states
+    set_state @state
+  end
+
+  # Override the send method.
+  #
+  # This was implemented to cover the case where test is used as a state.
+  # In that case, the default behavior was to call the private
+  # test method from Kernel. This prevents that behavior in cases where a
+  # public method is available via method_missing in this class.
+  def send(method, *args)
+    return method_missing(method, *args) if respond_to_missing?(method, false)
+    super
+  end
+
+  # Sets the state instance variable.
+  # ==== Input
+  # [value : Symbol] The value that will be used for the state.
+  def state=(value)
+    set_state value
+  end
+
+  ############################################################################
+  private
+  ############################################################################
+
+  # Returns the appropriate state to use when setting the state dynamically.
+  # ==== Output
+  # [Symbol] The state that should be used when setting the state dynamically.
+  def dynamic_state
+    call = origin
+    return @valid_states[0] unless call.sub(/^\.\//, '').match(/\//)
+
+    case call
+      when /rake_test_loader\.rb/,
+          %r[/tests?/test_\w+?.rb], %r[/tests?/\w+?_test.rb]
+        return @valid_states[1]
+      when %r[/bin/rake]
+        return @valid_states[2]
+    end
+
+    return @valid_states.last
+  end
+
+  # Allows the getting of the state since valid states
+  # may be specified at run time.
+  # ==== Input
+  # [method : Symbol] The method that was called.
+  # [*args : Array] Any arguments that were passed in.
+  # [&block : Block] A block, if specified.
+  def method_missing(method, *args, &block)
+    return method == @state if respond_to_missing?(method, false)
+    super
+  end
+
+  # Returns the first call in the stack.
+  # ==== Output
+  # [String] The file that made the first call in the stack.
+  # ==== Notes
+  # This method is overridden during tests.
+  def origin
+    caller.last
+  end
+
+  # Ensure that the object knows what it can respond to via method_missing.
+  # ==== Input
+  # [method : Symbol] The method to check for a response to.
+  # [include_private : Boolean] Whether to include private methods.
+  # ==== Output
+  # [Boolean] Indicates whether the object will respond to the specified method.
+  def respond_to_missing?(method, include_private)
+    return true if @valid_states.include?(method)
+    super
+  end
+
+  # Sets the state.
+  # ==== Input
+  # [value : Symbol] The value to use for the state.
+  def set_state(value)
+    unless @valid_states.include?(value) || value == :dynamic
+      raise "Invalid environment setting: '#{value}'."
+    end
+
+    if value == :dynamic
+      @state = dynamic_state || @valid_states.last
+    else
+      @state = value
+    end
+  end
+end

data/lib/app_mode.rb

@@ -1,3 +1,4 @@
 gem_name = File.basename(__FILE__, '.rb')
 
+require_relative File.join(gem_name, 'state_manager')
 require_relative File.join(gem_name, gem_name)

data/test/app_mode_test.rb

@@ -33,217 +33,14 @@
 require_relative 'require'
 
 class AppModeTest < Test::Unit::TestCase
-  include AppModeSupport
+  include StateManagerSupport
 
   def setup
     @class = AppMode
     @class.setup
-    @obj = nil
     super
   end
 
-  def test_class_type
-    assert_equal AppMode, @class
-  end
-
-  ############################################################################
-  # Instance tests.
-  ############################################################################
-
-  def test_default_settings
-    create
-
-    assert_equal :production, @obj.state
-    assert_equal states(:default), @obj.valid_states
-
-    assert_true @obj.production
-    assert_false @obj.development
-    assert_false @obj.test
-  end
-
-  def test_setting_state
-    create :test
-
-    assert_equal :test, @obj.state
-    assert_true @obj.test
-
-    assert_nothing_raised { @obj.state = :development }
-
-    assert_equal :development, @obj.state
-    assert_true @obj.development
-  end
-
-  def test_new_object
-    create :test
-    assert_equal :test, @obj.state
-    assert_false @obj.development
-    assert_true @obj.test
-    assert_false @obj.rake
-    assert_false @obj.production
-
-    create :development
-    assert_equal :development, @obj.state
-    assert_true @obj.development
-    assert_false @obj.test
-    assert_false @obj.rake
-    assert_false @obj.production
-
-    create :production
-    assert_equal :production, @obj.state
-    assert_false @obj.development
-    assert_false @obj.test
-    assert_false @obj.rake
-    assert_true @obj.production
-
-    create :rake
-    assert_equal :rake, @obj.state
-    assert_false @obj.development
-    assert_false @obj.test
-    assert_true @obj.rake
-    assert_false @obj.production
-  end
-
-  def test_dynamic_state
-    assert_nothing_raised { create :dynamic }
-    assert_false @obj.development
-    assert_false @obj.test
-    assert_false @obj.rake
-    assert_true @obj.production
-
-    assert_nothing_raised { create :dynamic, states(:dev) }
-    assert_true @obj.dev_dev
-    assert_false @obj.dev_test
-    assert_false @obj.dev_rake
-    assert_false @obj.dev_prod
-
-    assert_nothing_raised { create :dynamic, states(:test) }
-    assert_false @obj.test_dev
-    assert_true @obj.test_test
-    assert_false @obj.test_rake
-    assert_false @obj.test_prod
-
-    assert_nothing_raised { create :dynamic, states(:rake) }
-    assert_false @obj.rake_dev
-    assert_false @obj.rake_test
-    assert_true @obj.rake_rake
-    assert_false @obj.rake_prod
-
-    assert_nothing_raised { create :dynamic, states(:prod) }
-    assert_false @obj.prod_dev
-    assert_false @obj.prod_test
-    assert_false @obj.prod_rake
-    assert_true @obj.prod_prod
-
-    assert_raise(NoMethodError) { @obj.dynamic }
-    assert_raise(NoMethodError) { @obj.test }
-
-    assert_nothing_raised { create :dynamic, states(:test_test_class) }
-    assert_false @obj.test_test_class_dev
-    assert_true @obj.test_ttc
-    assert_false @obj.rake
-    assert_false @obj.prod
-
-    assert_nothing_raised { create :dynamic, states(:tests_test_class) }
-    assert_false @obj.tests_test_class_dev
-    assert_true @obj.test_stc
-    assert_false @obj.rake
-    assert_false @obj.prod
-
-    assert_nothing_raised { create :dynamic, states(:test_class_test) }
-    assert_false @obj.test_class_test_dev
-    assert_true @obj.test_tct
-    assert_false @obj.rake
-    assert_false @obj.prod
-
-    assert_nothing_raised { create :dynamic, states(:tests_class_test) }
-    assert_false @obj.tests_class_test_dev
-    assert_true @obj.test_sct
-    assert_false @obj.rake
-    assert_false @obj.prod
-  end
-
-  def test_dynamic_state_with_less_than_ideal_number_of_states
-    [
-      :dev,
-      :test,
-      :rake,
-      :prod,
-    ].each do |state|
-      state_array = states(state)[0..3]
-      end_value = state_array.length - 1
-
-      (0..end_value).each do |i|
-        assert_nothing_raised { create :dynamic, states(state)[0..i] }
-        case i
-          when 0
-            assert_true @obj.send("#{state}_dev")
-          when 1
-            case state
-              when :dev
-                assert_true @obj.dev_dev
-              else
-                assert_true @obj.send("#{state}_test")
-            end
-          when 2
-            case state
-              when :dev
-                assert_true @obj.dev_dev
-              when :test
-                assert_true @obj.test_test
-              else
-                assert_true @obj.send("#{state}_rake")
-            end
-          when 3
-            case state
-              when :dev
-                assert_true @obj.dev_dev
-              when :test
-                assert_true @obj.test_test
-              when :rake
-                assert_true @obj.rake_rake
-              when :prod
-                assert_true @obj.prod_prod
-            end
-        end
-      end
-    end
-  end
-
-  def test_invalid_state
-    assert_raise(RuntimeError) { create :invalid }
-    assert_raise(NoMethodError) { create :test; @obj.invalid }
-  end
-
-  def test_respond_to
-    create :test
-
-    method_list.each_value do |method|
-      assert_respond_to @obj, method
-    end
-
-    states(:default).each do |method|
-      assert_respond_to @obj, method
-    end
-
-    assert_not_respond_to @obj, :invalid
-  end
-
-  # This test exists because of Kernel::test.
-  def test_send_method
-    create :test
-    assert_equal :test, @obj.send(:state)
-    assert_false @obj.send(:development)
-    assert_true @obj.send(:test)
-    assert_false @obj.send(:rake)
-    assert_false @obj.send(:production)
-
-    create :development, [:development, :production]
-    assert_equal :development, @obj.send(:state)
-    assert_true @obj.send(:development)
-    assert_false @obj.send(:production)
-    assert_raise(ArgumentError) { @obj.send(:test) }
-  end
-
   ############################################################################
   # Class tests.
   ############################################################################
@@ -305,14 +102,14 @@ class AppModeTest < Test::Unit::TestCase
     assert_raise(ArgumentError) { @class.send(:test) }
   end
 
+  def test_initialize_object_should_fail
+    assert_raise(NotImplementedError) { @class.new }
+  end
+
   ############################################################################
   private
   ############################################################################
 
-  def create(*args)
-    @obj = @class.new(*args)
-  end
-
   ############################################################################
   # Assertions - stolen from test_internals.
   ############################################################################

data/test/lib/{app_mode.rb → state_manager.rb}

@@ -32,7 +32,7 @@
 ################################################################################
 #++
 
-class AppMode
+class StateManager
   ############################################################################
   private
   ############################################################################

data/test/lib/{app_mode_support.rb → state_manager_support.rb}

@@ -36,7 +36,7 @@
 # This module is provided to be used as an include in any necessary class.
 #
 # This serves as a bridge between test code and application code.
-module AppModeSupport
+module StateManagerSupport
   # These are things that will be used throughout testing in multiple locations.
   ITEMS = {
     :states => {

data/test/require.rb

@@ -2,7 +2,7 @@ Bundler.require :test
 
 require 'test/unit'
 
-require_relative '../lib/app_mode/app_mode'
+require_relative '../lib/app_mode'
 
-require_relative 'lib/app_mode_support'
-require_relative 'lib/app_mode'
+require_relative 'lib/state_manager_support'
+require_relative 'lib/state_manager'

data/test/state_manager_test.rb

@@ -0,0 +1,265 @@
+#--
+################################################################################
+#                      Copyright (C) 2011 Travis Herrick                       #
+################################################################################
+#                                                                              #
+#                                 \v^V,^!v\^/                                  #
+#                                 ~%       %~                                  #
+#                                 {  _   _  }                                  #
+#                                 (  *   -  )                                  #
+#                                 |    /    |                                  #
+#                                  \   _,  /                                   #
+#                                   \__.__/                                    #
+#                                                                              #
+################################################################################
+# This program is free software: you can redistribute it                       #
+# and/or modify it under the terms of the GNU General Public License           #
+# as published by the Free Software Foundation,                                #
+# either version 3 of the License, or (at your option) any later version.      #
+#                                                                              #
+# Commercial licensing may be available for a fee under a different license.   #
+################################################################################
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY;                                                    #
+# without even the implied warranty of MERCHANTABILITY                         #
+# or FITNESS FOR A PARTICULAR PURPOSE.                                         #
+# See the GNU General Public License for more details.                         #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.        #
+################################################################################
+#++
+
+require_relative 'require'
+
+class StateManagerTest < Test::Unit::TestCase
+  include StateManagerSupport
+
+  def setup
+    @class = StateManager
+    @obj = nil
+    super
+  end
+
+  def test_default_settings
+    create
+
+    assert_equal :production, @obj.state
+    assert_equal states(:default), @obj.valid_states
+
+    assert_true @obj.production
+    assert_false @obj.development
+    assert_false @obj.test
+  end
+
+  def test_setting_state
+    create :test
+
+    assert_equal :test, @obj.state
+    assert_true @obj.test
+
+    assert_nothing_raised { @obj.state = :development }
+
+    assert_equal :development, @obj.state
+    assert_true @obj.development
+  end
+
+  def test_new_object
+    create :test
+    assert_equal :test, @obj.state
+    assert_false @obj.development
+    assert_true @obj.test
+    assert_false @obj.rake
+    assert_false @obj.production
+
+    create :development
+    assert_equal :development, @obj.state
+    assert_true @obj.development
+    assert_false @obj.test
+    assert_false @obj.rake
+    assert_false @obj.production
+
+    create :production
+    assert_equal :production, @obj.state
+    assert_false @obj.development
+    assert_false @obj.test
+    assert_false @obj.rake
+    assert_true @obj.production
+
+    create :rake
+    assert_equal :rake, @obj.state
+    assert_false @obj.development
+    assert_false @obj.test
+    assert_true @obj.rake
+    assert_false @obj.production
+  end
+
+  def test_dynamic_state
+    assert_nothing_raised { create :dynamic }
+    assert_false @obj.development
+    assert_false @obj.test
+    assert_false @obj.rake
+    assert_true @obj.production
+
+    assert_nothing_raised { create :dynamic, states(:dev) }
+    assert_true @obj.dev_dev
+    assert_false @obj.dev_test
+    assert_false @obj.dev_rake
+    assert_false @obj.dev_prod
+
+    assert_nothing_raised { create :dynamic, states(:test) }
+    assert_false @obj.test_dev
+    assert_true @obj.test_test
+    assert_false @obj.test_rake
+    assert_false @obj.test_prod
+
+    assert_nothing_raised { create :dynamic, states(:rake) }
+    assert_false @obj.rake_dev
+    assert_false @obj.rake_test
+    assert_true @obj.rake_rake
+    assert_false @obj.rake_prod
+
+    assert_nothing_raised { create :dynamic, states(:prod) }
+    assert_false @obj.prod_dev
+    assert_false @obj.prod_test
+    assert_false @obj.prod_rake
+    assert_true @obj.prod_prod
+
+    assert_raise(NoMethodError) { @obj.dynamic }
+    assert_raise(NoMethodError) { @obj.test }
+
+    assert_nothing_raised { create :dynamic, states(:test_test_class) }
+    assert_false @obj.test_test_class_dev
+    assert_true @obj.test_ttc
+    assert_false @obj.rake
+    assert_false @obj.prod
+
+    assert_nothing_raised { create :dynamic, states(:tests_test_class) }
+    assert_false @obj.tests_test_class_dev
+    assert_true @obj.test_stc
+    assert_false @obj.rake
+    assert_false @obj.prod
+
+    assert_nothing_raised { create :dynamic, states(:test_class_test) }
+    assert_false @obj.test_class_test_dev
+    assert_true @obj.test_tct
+    assert_false @obj.rake
+    assert_false @obj.prod
+
+    assert_nothing_raised { create :dynamic, states(:tests_class_test) }
+    assert_false @obj.tests_class_test_dev
+    assert_true @obj.test_sct
+    assert_false @obj.rake
+    assert_false @obj.prod
+  end
+
+  def test_dynamic_state_with_less_than_ideal_number_of_states
+    [
+      :dev,
+      :test,
+      :rake,
+      :prod,
+    ].each do |state|
+      state_array = states(state)[0..3]
+      end_value = state_array.length - 1
+
+      (0..end_value).each do |i|
+        assert_nothing_raised { create :dynamic, states(state)[0..i] }
+        case i
+          when 0
+            assert_true @obj.send("#{state}_dev")
+          when 1
+            case state
+              when :dev
+                assert_true @obj.dev_dev
+              else
+                assert_true @obj.send("#{state}_test")
+            end
+          when 2
+            case state
+              when :dev
+                assert_true @obj.dev_dev
+              when :test
+                assert_true @obj.test_test
+              else
+                assert_true @obj.send("#{state}_rake")
+            end
+          when 3
+            case state
+              when :dev
+                assert_true @obj.dev_dev
+              when :test
+                assert_true @obj.test_test
+              when :rake
+                assert_true @obj.rake_rake
+              when :prod
+                assert_true @obj.prod_prod
+            end
+        end
+      end
+    end
+  end
+
+  def test_invalid_state
+    assert_raise(RuntimeError) { create :invalid }
+    assert_raise(NoMethodError) { create :test; @obj.invalid }
+  end
+
+  def test_respond_to
+    create :test
+
+    method_list.each_value do |method|
+      assert_respond_to @obj, method
+    end
+
+    states(:default).each do |method|
+      assert_respond_to @obj, method
+    end
+
+    assert_not_respond_to @obj, :invalid
+  end
+
+  # This test exists because of Kernel::test.
+  def test_send_method
+    create :test
+    assert_equal :test, @obj.send(:state)
+    assert_false @obj.send(:development)
+    assert_true @obj.send(:test)
+    assert_false @obj.send(:rake)
+    assert_false @obj.send(:production)
+
+    create :development, [:development, :production]
+    assert_equal :development, @obj.send(:state)
+    assert_true @obj.send(:development)
+    assert_false @obj.send(:production)
+    assert_raise(ArgumentError) { @obj.send(:test) }
+  end
+
+  ############################################################################
+  private
+  ############################################################################
+
+  def create(*args)
+    @obj = @class.new(*args)
+  end
+
+  ############################################################################
+  # Assertions - stolen from test_internals.
+  ############################################################################
+
+  # Asserts that a value is equal to false.
+  # ==== Input
+  # [value : Any] The value to check for equality against false.
+  # [message : String : nil] The message to display if the value is not false.
+  def assert_false(value, message = nil)
+    assert_equal false, value, message
+  end
+
+  # Asserts that a value is equal to true.
+  # ==== Input
+  # [value : Any] The value to check for equality against true.
+  # [message : String : nil] The message to display if the value is not true.
+  def assert_true(value, message = nil)
+    assert_equal true, value, message
+  end
+end

metadata

@@ -3,10 +3,10 @@ name: app_mode
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
+  - 1
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  version: 1.0.0
 platform: ruby
 authors: 
 - Travis Herrick
@@ -42,6 +42,7 @@ extra_rdoc_files:
 - README
 files: 
 - lib/app_mode/app_mode.rb
+- lib/app_mode/state_manager.rb
 - lib/app_mode.rb
 - Gemfile.lock
 - Gemfile
@@ -49,9 +50,10 @@ files:
 - app_mode.gemspec
 - README
 - test/require.rb
+- test/lib/state_manager.rb
+- test/lib/state_manager_support.rb
 - test/app_mode_test.rb
-- test/lib/app_mode.rb
-- test/lib/app_mode_support.rb
+- test/state_manager_test.rb
 has_rdoc: true
 homepage: http://www.bitbucket.org/ToadJamb/gems_app_mode
 licenses: 
@@ -66,7 +68,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 1255421514984567375
+      hash: 3211737509278320283
       segments: 
       - 0
       version: "0"
@@ -84,9 +86,10 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Application state management.
+summary: State management for objects and applications.
 test_files: 
 - test/require.rb
+- test/lib/state_manager.rb
+- test/lib/state_manager_support.rb
 - test/app_mode_test.rb
-- test/lib/app_mode.rb
-- test/lib/app_mode_support.rb
+- test/state_manager_test.rb