development 1.0.8 → 1.1.0

data/lib/development/gemset.rb

@@ -0,0 +1,9 @@
+
+###
+# Gemset class.
+#
+class ::Development::Gemset
+  
+  include ::Development::Gemset::GemsetInterface
+  
+end

data/lib/development.rb

@@ -1,949 +1,619 @@
 
+# namespaces that have to be declared ahead of time for proper load order
+require_relative './namespaces'
+
+# source file requires
+require_relative './requires.rb'
+
 ###
 # Singleton that manages configurations and requires.
 #
 module ::Development
-  
-  #############
-  #  loaded?  #
-  #############
 
   ###
-  # Query whether gem was loaded via Development rather than standard require.
-  #
-  # @param gem_name
-  #
-  #        Name of gem.
-  #
-  # @return [true,false] Whether gem was loaded via Development.
+  # Name of configuration file: .development.rb.
   #
-  def loaded?( gem_name )
-    
-    return @loaded_gems.has_key?( gem_name.to_sym )
-    
-  end
-  
-  ####################
-  #  self.directory  #
-  ####################
+  ConfigurationFileName = '.development.rb'
+
+  #####################
+  #  self.initialize  #
+  #####################
   
   ###
-  # Return path for directory name.
-  #
-  # @param directory_name
+  # Initialize internal tracking variables.
   #
-  #        Name of named directory.
-  #
-  # @return [String] Directory path associated with directory name.
+  # @return [Development] Self.
   #
-  def self.directory( directory_name )
+  def self.initialize
 
-    return @named_directories[ directory_name.to_sym ]
+    @enable_for_all = false
     
-  end
-  
-  #############################
-  #  self.general_load_paths  #
-  #############################
-  
-  ###
-  # Get Array of paths that will be used for general loading purposes if a specific gem path is not given.
-  #
-  # @return [Array<String>] Paths to be used for general loading purposes.
-  #
-  def self.general_load_paths
+    @directories = { }
+    
+    @gems = { }
+    @gemsets = { }
 
-    return @general_load_paths
+    @general_load_paths = [ ]
+
+    @loaded_gems = { }
 
+    return self
+    
   end
 
-  ############################
-  #  self.named_directories  #
-  ############################
+  ################
+  #  self.clear  #
+  ################
   
   ###
-  # Get Hash of named directory names to paths.
+  # Reset internal tracking variables.
   #
-  # @return [Hash{Symbol=>String}]
+  # @return [Development] Self.
   #
-  def self.named_directories
+  def self.clear
+    
+    @enable_for_all = false
 
-    return @named_directories
+    @directories.clear
 
-  end
+    @gems.clear
+    @gemsets.clear
 
-  ###########################
-  #  self.enabled_for_all?  #
-  ###########################
-  
-  ###
-  # Query whether Development is set to search in general paths for any gem, even if not explicitly enabled.
-  #
-  # @return [true,false] Whether general gem search is enabled.
-  #
-  def self.enabled_for_all?
+    @general_load_paths.clear
+
+    @loaded_gems.clear
     
-    return @enable_for_all
+    return self
     
   end
 
-  #######################
-  #  self.enabled_gems  #
-  #######################
+  ##############
+  #  self.gem  #
+  ##############
   
   ###
-  # Get gems that have been explicitly enabled.
+  # Define a gem or retrieve defined gem.
   #
-  # @return [Array<Symbol>] Array of gem or gemset names.
+  # @param name
   #
-  def self.enabled_gems
-    
-    return @enabled_gems.keys
-    
-  end
-
-  ########################
-  #  self.disabled_gems  #
-  ########################
-  
-  ###
-  # Get gems that have been explicitly disabled.
+  #        Name of gem.
+  #
+  # @param directory_or_path
   #
-  # @return [Array<Symbol>] Array of gem or gemset names.
+  #        Development::Directory or String describing path.
   #
-  def self.disabled_gems
+  # @return [::Development::Gem]
+  #
+  def self.gem( name, directory_or_path = nil )
 
-    return @disabled_gems.keys
+    gem_require_name = name.to_s.gsub( '/', '-' )
 
-  end
+    name = gem_require_name.to_sym
+
+    if gem_instance = @gems[ name ]
+      if directory_or_path
+        gem_instance.set_directory( directory_or_path )
+      end
+    else
+      @gems[ name ] = gem_instance = Gem.new( name, directory_or_path )
+    end
+    
+    return gem_instance
 
+  end
+  
   ##################
-  #  self.gemsets  #
+  #  self.get_gem  #
   ##################
   
   ###
-  # Get hash of gemsets and their gem or gemset members.
+  # Retrieve defined gem.
   #
-  # @return [Hash{Symbol=>Array<Symbol>}] Hash of gemsets and their gem or gemset members.
+  # @param name
   #
-  def self.gemsets
+  #        Name of gem.
+  #
+  # @return [::Development::Gem]
+  #
+  def self.get_gem( name )
     
-    return @gemsets
+    return @gems[ name.to_sym ]
     
   end
-
-  ####################
-  #  self.locations  #
-  ####################
+  
+  ###############
+  #  self.gems  #
+  ###############
   
   ###
-  # Hash of locations and the gems or gemsets located at each.
+  # Get hash of gems.
   #
-  # @return [Hash{Symbol=>Array{String}] 
+  # @return [Hash{Symbol=>Array<::Development::Gem>}] Hash of gemsets and their gem or gemset members.
   #
-  def self.locations
+  def self.gems
     
-    return @locations
+    return @gems
     
   end
 
-  ###################
-  #  self.location  #
-  ###################
+  #################
+  #  self.gemset  #
+  #################
   
   ###
-  # Get gems or gemsets associated with location.
+  # Define a gem or retrieve defined gem.
+  #
+  # @overload self.gemset( name, gem_or_gemset, ... )
   #
-  # @param location_name
+  #   @param name
+  #   
+  #          Name of gemset.
   #
-  #        Name of location.
+  #   @param gem_or_gemset
   #
-  # @return [Array<Symbol>]
+  #          Gem or Gemset name or instance.
   #
-  def self.location( location_name )
+  # @return [::Development::Gemset]
+  #
+  def self.gemset( name, *gems_or_gemsets )
+
+    name = name.to_sym
+    
+    unless gemset_instance = @gemsets[ name ]
+      @gemsets[ name ] = gemset_instance = Gemset.new( name )
+    end
     
-    return @locations[ location_name.to_sym ]
+    gemset_instance.add( *gems_or_gemsets )
+    
+    return gemset_instance
     
   end
   
-  ######################################################################################################################
-      private ##########################################################################################################
-  ######################################################################################################################
+  #####################
+  #  self.get_gemset  #
+  #####################
   
   ###
-  # @private
+  # Retrieve defined gemset.
   #
-  # Container to namespace exceptions.
-  #
-  module Exception
-  end
-
-  ###
-  # Name of configuration file: .development.
+  # @param name
   #
-  ConfigurationFileName = '.development'
-  
-  @enabled_gems = { }
-  @disabled_gems = { }
-  
-  @gemsets = { }
-  @gem_locations = { }
-  
-  @general_load_paths = [ ]
-
-  @loaded_gems = { }
-
-  @named_directories = { }
-  @locations = { }
-
-  @enable_for_all = false
-
-  ################
-  #  self.clear  #
-  ################
-  
-  ###
-  # Reset internal tracking variables.
+  #        Name of gemset.
   #
-  # @return [Development] Self.
+  # @return [::Development::Gemset]
   #
-  def self.clear
+  def self.get_gemset( name )
     
-    @enabled_gems.clear
-    @disabled_gems.clear
-    @gemsets.clear
-    @gem_locations.clear
-    @general_load_paths.clear
-    @loaded_gems.clear
-    @named_directories.clear
-    @locations.clear
-    @enable_for_all = false
-    
-    return self
+    return @gemsets[ name.to_sym ]
     
   end
   
-  ##################################
-  #  self.load_configuration_file  #
-  ##################################
+  ##################
+  #  self.gemsets  #
+  ##################
   
   ###
-  # Load configuration file.
-  #   Looks first in project directory, second in home directory. 
-  #   If configuration file is not found in project directory, Development will not load.
+  # Get hash of gemsets and their gem or gemset members.
   #
-  def self.load_configuration_file( path )
-        
-    # we build up a configuration line and process when we reach its end (the next line)
-    expression_string = ''
-
-    configuration_file_path = ::File.expand_path( path )
-    
-    @line_number = 0
-
-    ::File.open( configuration_file_path ).each_with_index do |this_line, this_line_number|
+  # @return [Hash{Symbol=>Array<::Development::Gemset>}] Hash of gemsets and their gem or gemset members.
+  #
+  def self.gemsets
     
-      # when parse_configuration_file_line returns false we have a complete expression
-      while parse_configuration_file_line( expression_string, this_line )
-
-        # process expression_string
-        parse_configuration_expression( expression_string )
-
-        # reset expression_string
-        expression_string.clear
-        
-        # update line number where expression begins
-        @line_number = this_line_number
-        unless this_line.empty?
-          @line_number += 1
-        end
-        
-        # loop will cause start with this_line, which told parse_configuration_file_line 
-        # that we were done, and which is therefore not yet processed
-        
-      end
-
-    end
-
-    parse_configuration_expression( expression_string )
+    return @gemsets
     
   end
-  
-  ########################################
-  #  self.parse_configuration_file_line  #
-  ########################################
+
+  ####################
+  #  self.directory  #
+  ####################
 
   ###
-  # Parses configuration_file_line to construct expression_string from multiple configuration_file_lines.
-  #
-  # @param expression_string 
-  #
-  #        Configuration expression that spans one or more lines in configuration file.
+  # Return path for directory name.
   #
-  # @param configuration_file_line 
+  # @overload self.directory( name, path, gem_or_gemset, ... )
   #
-  #        Literal line from configuration file (may only be part of an expression).
+  #   @param directory_name
+  #   
+  #          Name of named directory.
+  #   
+  #   @param path_parts
+  #   
+  #          The first can be a Symbol naming a directory; any can be String describing directory path.
   #
-  # @return [true,false] Whether expression is still complete. 
-  #                      True means configuration_file_line was not processed.
+  # @return [::Development::Directory] Directory.
   #
-  def self.parse_configuration_file_line( expression_string, configuration_file_line, continuation = false )
-
-    expression_complete = false
-
-    # if we begin with a comment we can throw away the line
-    if configuration_file_line[ 0 ] == '#'
-      
-      # nothing to do - we just ignore the line
-      
-    # if we begin with whitespace we have a continuation
-    elsif configuration_file_line[ 0 ] =~ /\s/
-      
-      configuration_file_line.strip!
-      
-      expression_complete = parse_configuration_file_line( expression_string, configuration_file_line, true )
+  def self.directory( name, *path_parts )
     
-    elsif continuation
-      
-      unless expression_string.empty?
-        unless configuration_file_line.empty?
-          expression_string << ' '
-        end
-      end
-      expression_string << configuration_file_line.strip
+    name = name.to_sym
 
-    elsif expression_string.empty?
-      
-      expression_string.replace( configuration_file_line.strip )
-    
-    # otherwise we reached the next line of the configuration file
+    if directory_instance = @directories[ name ]
+      unless path_parts.empty?
+        directory_instance.set_path( *path_parts )
+      end
     else
-
-      expression_complete = true
-
+      if path_parts.empty?
+        raise ::ArgumentError, 'Path required to create directory :' << name.to_s + '.'
+      end
+      @directories[ name ] = directory_instance = Directory.new( name, *path_parts )
     end
-    
-    return expression_complete
-    
-  end
-  
-  #########################################
-  #  self.parse_configuration_expression  #
-  #########################################
-  
-  ###
-  # Parse single configuration expression built up from one or more actual configuration file lines.
-  #
-  # @param expression_string
-  #
-  #        String describing configuration directive.
-  #
-  # @return [Object] self.
-  #
-  def self.parse_configuration_expression( expression_string )
-    
-    case expression_string[ 0 ]
-      
-      # + - named directory expression
-      when '+'
-
-        # either a directory definition or a general directory directive
-        # directory definitions are multiplart, whereas general directory definitions are one part
-        parse_named_directory_expression( expression_string )
-                
-      # - - remove general path
-      when '-'
-
-        parse_remove_general_load_path_expression( expression_string )
-
-      # = - gemset expression
-      when '='
-
-        parse_gemset_expression( expression_string )
-
-      # @ - location expression
-      when '@'
-
-        parse_general_directory_or_location_expression( expression_string )
 
-      # ! - enable/disable expression
-      when '!'
-
-        parse_enable_disable_expression( expression_string )
-      
-      # general path expression
-      else
-
-        parse_general_load_path_expression( expression_string )
-      
-    end
-    
-    return self
+    return directory_instance
     
   end
   
-  #########################################################
-  #  self.parse_general_directory_or_location_expression  #
-  #########################################################
+  ########################
+  #  self.get_directory  #
+  ########################
   
   ###
-  # Parse expression string that has been determined as either a general path or location expression.
+  # Return directory with name.
   #
-  # @param expression_string
+  # @param name
   #
-  #        String describing general path or location expression.
+  #        Name of directory to return.
   #
-  # @return [Object] Self.
+  # @return [::Development::Directory] Directory.
   #
-  def self.parse_general_directory_or_location_expression( expression_string )
-    
-    # if we have multiple parts
-    if whitespace_index = expression_string =~ /\s/
-      
-      parse_location_expression( expression_string )
+  def self.get_directory( name )
     
-    # if we have one part
-    else
-      
-      parse_general_load_path_expression( expression_string )
-      
-    end
-    
-    return self
+    return @directories[ name.to_sym ]
     
   end
-  
-  ###########################################
-  #  self.parse_named_directory_expression  #
-  ###########################################
+
+  ######################
+  #  self.directories  #
+  ######################
   
   ###
-  # Parse expression string that has been determined as a named directory expression.
-  #
-  # @param expression_string
-  #
-  #        String describing named directory expression.
+  # Get Hash of named directory names to paths.
   #
-  # @return [Object] Self.
+  # @return [Hash{Symbol=>::Development::Directory}]
   #
-  def self.parse_named_directory_expression( expression_string )
-    
-    # +directory_name path
+  def self.directories
 
-    unless whitespace_index = expression_string =~ /\s/
-      raise Exception::MalformedExpression::
-            MalformedNamedDirectoryExpression.new( expression_string, @line_number )
-    end
+    return @directories
 
-    directory_name = expression_string.slice( 1, whitespace_index - 1 )
-    slice_length = expression_string.length - whitespace_index
-    path = expression_string.slice( whitespace_index + 1, slice_length ).strip
+  end
 
-    case path[0]
-      when '@'
-        path_parts = path.split( '/' )
-        named_path_name = path_parts.shift
-        named_path_name.slice!( 0, 1 )
-        path = ::File.join( directory( named_path_name ), path_parts )
-    end
+  ############################
+  #  self.general_load_path  #
+  ############################
+
+  ###
+  # Define general load path.
+  #   
+  # @param path
+  # 
+  #        String describing directory path.
+  #
+  # @return [::Development] Self.
+  #
+  def self.general_load_path( path )
     
-    @named_directories[ directory_name.to_sym ] = ::File.expand_path( path )
+    @general_load_paths.push( ::File.expand_path( path ) )
     
     return self
     
   end
 
-  ##################################
-  #  self.parse_gemset_expression  #
-  ##################################
+  ###################################
+  #  self.remove_general_load_path  #
+  ###################################
 
   ###
-  # Parse expression string that has been determined as a gemset expression.
-  #
-  # @param expression_string
-  #
-  #        String describing gemset expression.
+  # Remove general load path.
+  #   
+  # @param path
+  # 
+  #        String describing directory path.
   #
-  # @return [Object] Self.
+  # @return [::Development] Self.
   #
-  def self.parse_gemset_expression( expression_string )
-
-    # =gemset gem_or_set_name[,] ...
-    # =gemset +gem_or_set_name[,] ...
-    # =gemset -gem_or_set_name[,] ...
-
-    gemset_name = parse_base_action_from_expression_string( expression_string )
-
-    gemset = create_gemset( gemset_name )
+  def self.remove_general_load_path( path )
     
-    parse_gem_names_from_expression_string( gemset, expression_string )
+    @general_load_paths.delete( ::File.expand_path( path ) )
     
     return self
     
   end
-
-  ###################################################
-  #  self.parse_base_action_from_expression_string  #
-  ###################################################
+  
+  #############################
+  #  self.general_load_paths  #
+  #############################
   
   ###
-  # Parse signal character (+, -, =, @, !) and base action string from expression.
+  # Get Array of paths that will be used for general loading purposes if a specific gem path is not given.
   #
-  # @param expression_string
+  # @return [Array<String>] Paths to be used for general loading purposes.
   #
-  #        Expression string.
+  def self.general_load_paths
+
+    return @general_load_paths
+
+  end  
+  
+  ###########################
+  #  self.enabled_for_all?  #
+  ###########################
+  
+  ###
+  # Query whether Development is set to search in general paths for any gem, even if not explicitly enabled.
   #
-  # @return [String] Base action string.
+  # @return [true,false] Whether general gem search is enabled.
   #
-  def self.parse_base_action_from_expression_string( expression_string )
-    
-    base_action = nil
-    
-    # get rid of =
-    expression_string.slice!( 0, 1 )
-    
-    if whitespace_index = expression_string =~ /\s/
-      base_action = expression_string.slice!( 0, whitespace_index )
-    else
-      base_action = expression_string.dup
-      expression_string.clear
-    end
+  def self.enabled_for_all?
     
-    expression_string.strip!
-
-    return base_action
+    return @enable_for_all
     
   end
-  
-  #################################################
-  #  self.parse_gem_names_from_expression_string  #
-  #################################################
+
+  ##################
+  #  self.enable!  #
+  ##################
 
   ###
-  # Parse gem name list separated by optional comma and white space from expression.
-  #
-  # @param hash
-  #
-  #        Hash to add parsed data to.
+  # Enable gems.
   #
-  # @param expression_string
+  # @overload enable!
   #
-  #        Expression string.
+  # @overload enable( gem_or_gemset, ... )
   #
-  # @param require_exist [true,false]
+  #   @param gem_or_gemset 
   #
-  #        Raise exception if gems do not exist.
+  #          Gem or Gemset instance or name to enable.
   #
-  # @return [Development] Self.
+  # @return [::Development] Self. 
   #
-  def self.parse_gem_names_from_expression_string( hash, expression_string, require_exist = false )
+  def self.enable!( *gem_or_gemset_names )
+    
+    if gem_or_gemset_names.empty?
 
-    while next_whitespace_index = expression_string =~ /\s/
-      parse_gem_name_from_expression_string( hash, expression_string, next_whitespace_index )
-    end
+      @enable_for_all = true
+      @gems.each do |this_gem_name, this_gem|
+        this_gem.enable!
+      end
+      @gemsets.each do |this_gemset_name, this_gemset|
+        this_gemset.enable!
+      end
+
+    else
+
+      gem_or_gemset_names.each do |this_gemset_or_gem_name|
+        if this_gemset_or_gem_name.is_a?( ::Hash )
+          this_gemset_or_gem_name.each do |this_gem, this_path|
+            gem_instance = gem( this_gem )
+            gem_instance.set_directory( this_path )
+            gem_instance.enable!
+          end
+        else
+          this_gem_or_gemset_reference_name = this_gemset_or_gem_name.to_s.gsub( '/', '-' ).to_sym
+          if gem_instance = @gems[ this_gem_or_gemset_reference_name ]
+            gem_instance.enable!
+          end
+          if gemset_instance = @gemsets[ this_gem_or_gemset_reference_name ]
+            gemset_instance.enable!
+          end
+        end
+      end
 
-    # also slice till the end
-    parse_gem_name_from_expression_string( hash, expression_string, expression_string.length, require_exist )
+    end
     
     return self
     
   end
 
-  ################################################
-  #  self.parse_gem_name_from_expression_string  #
-  ################################################
-  
+  ###################
+  #  self.disable!  #
+  ###################
+
   ###
-  # Helper method to slice gem name from expression string and add or subtract from gemset.
-  #
-  # @param hash
+  # Disable gems.
   #
-  #        Hash to add parsed data to.
+  # @overload disable!
   #
-  # @param gemset
+  # @overload disable( gem_or_gemset, ... )
   #
-  #        Gemset instance.
+  #   @param gem_or_gemset 
   #
-  # @param expression_string
+  #          Gem or Gemset instance or name to disable.
   #
-  #        Expression string.
-  # 
-  # @param slice_to_index
-  #
-  #        Index to slice expression string to.
-  #
-  # @param require_exist [true,false]
-  #
-  #        Raise exception if gems do not exist.
+  # @return [::Development] Self. 
   #
-  # @return [Symbol] Parsed gem name.
-  #
-  def self.parse_gem_name_from_expression_string( hash, expression_string, slice_to_index, require_exist = false )
-    
-    gem_name = expression_string.slice!( 0, slice_to_index )
+  def self.disable!( *gem_or_gemset_names )
 
-    unless gem_name.empty?
-            
-      case gem_name[ -1 ]
-        when ','
-          gem_name.slice!( -1, 1 )
+    if gem_or_gemset_names.empty?
+
+      @enable_for_all = false
+      @gems.each do |this_gem_name, this_gem|
+        this_gem.disable!
       end
-    
-      should_add = true
-      
-      case gem_name[ 0 ]
-        when '+'
-          gem_name.slice!( 0, 1 )
-        when '-'
-          gem_name.slice!( 0, 1 )
-          hash.delete( gem_name.to_sym )
-          should_add = false
-        else
+      @gemsets.each do |this_gemset_name, this_gemset|
+        this_gemset.disable!
       end
 
-      # ensure we have 'gem-subname' rather than 'gem/subname'
-      # we really just need one or the other consistently
-      gem_name.gsub!( '/', '-' )
-
-      gem_name = gem_name.to_sym
+    else
 
-      if require_exist
-        unless @enabled_gems.has_key?( gem_name ) or 
-               @disabled_gems.has_key?( gem_name ) or 
-               @gemsets.has_key?( gem_name)
-          raise Exception::ExpressionError::UnknownGemOrGemsetName.new( gem_name, @line_number )
+      gem_or_gemset_names.each do |this_gemset_or_gem_name|
+        this_gem_or_gemset_reference_name = this_gemset_or_gem_name.to_s.gsub( '/', '-' ).to_sym
+        if gem_instance = @gems[ this_gem_or_gemset_reference_name ]
+          gem_instance.disable!
+        end
+        if gemset_instance = @gemsets[ this_gem_or_gemset_reference_name ]
+          gemset_instance.disable!
         end
       end
 
-      if should_add
-        hash[ gem_name ] = true
-      end
-      
-      expression_string.strip!
-
     end
-    
-    return gem_name
-    
-  end
 
-  ########################
-  #  self.create_gemset  #
-  ########################
-  
-  ###
-  # Create gemset with name.
-  #
-  # @param gemset_name
-  #
-  #        Name of gemset.
-  #
-  # @return [Array] Gemset.
-  #
-  def self.create_gemset( gemset_name )
+    return self
 
-    gemset_name = gemset_name.to_sym
-    
-    unless gemset = @gemsets[ gemset_name ]
-      @gemsets[ gemset_name ] = gemset = { }
-    end
-    
-    return gemset
-    
   end
-
-  #################
-  #  self.gemset  #
-  #################
   
+  #############
+  #  loaded?  #
+  #############
+
   ###
-  # Get gemset with name.
+  # Query whether gem was loaded via Development rather than standard require.
   #
-  # @param gemset_name
+  # @param gem_name
   #
-  #        Name of gemset.
+  #        Name of gem.
   #
-  # @return [Array] Gemset.
+  # @return [true,false] Whether gem was loaded via Development.
   #
-  def self.gemset( gemset_name )
-    
-    gemset_members = nil  
+  def loaded?( gem_name )
     
-    if gemset = @gemsets[ gemset_name.to_sym ]
-      gemset_members = gemset.keys
-    end
+    gem_require_name = gem_name.to_s.gsub( '/', '-' )
     
-    return gemset_members
+    return @loaded_gems.has_key?( gem_require_name.to_sym )
     
   end
-
-  ####################################
-  #  self.parse_location_expression  #
-  ####################################
+  
+  ######################################################################################################################
+      private ##########################################################################################################
+  ######################################################################################################################
     
+  initialize
+
+  ##################
+  #  self.require  #
+  ##################
+  
   ###
-  # Parse expression string that has been determined as a location expression.
+  # Filters requires to match configuration specifications for loading development paths instead of production gems.
   #
-  # @param expression_string
+  # @param gem_name_or_path
   #
-  #        String describing location expression.
+  #        Gem name or path to file passed to {::Object#require}.
   #
-  # @return [Object] Self.
+  # @return [true,false] Whether Development handled gem_name_or_path (true) or processing should continue (false).
   #
-  def self.parse_location_expression( expression_string )
-    
-    # @directory_name gem_or_set_name[,] ...
-    
-    directory_name = parse_base_action_from_expression_string( expression_string )
-    
-    directory_name = directory_name.to_sym
-    
-    unless @named_directories.has_key?( directory_name )
-      raise Exception::MalformedExpression::UnknownDirectoryName.new( directory_name, @line_number )
-    end
-    
-    unless directory_members = @locations[ directory_name ]
-      @locations[ directory_name ] = directory_members = { }
-    end
-    
-    parse_gem_names_from_expression_string( directory_members, expression_string )
-    
-    directory_members.each do |this_gem_or_gemset, true_value|
-      if gemset = @gemsets[ this_gem_or_gemset ]
-        gemset.each do |this_gem, true_value|
-          @gem_locations[ this_gem ] = directory_name
-        end
-      else
-        @gem_locations[ this_gem_or_gemset ] = directory_name
-      end
-    end
-    
-    return self
+  def self.require( gem_name_or_path )
     
-  end
+    did_load = nil
 
-  ##########################################
-  #  self.parse_enable_disable_expression  #
-  ##########################################
+    # if our path ends with an extension we are not requiring a gem and thus not responsible for managing it
+    if ::File.extname( gem_name_or_path ).empty?
 
-  ###
-  # Parse expression string that has been determined as a enable/disable expression.
-  #
-  # @param expression_string
-  #
-  #        String describing enable/disable expression.
-  #
-  # @return [Object] Self.
-  #
-  def self.parse_enable_disable_expression( expression_string )
-    
-    # !enable
-    # !disable
-    # !enable gem_or_set_name[,] ...
-    # !disable gem_or_set_name[,] ...
-    
-    # enable or disable
-    enable_or_disable = parse_base_action_from_expression_string( expression_string )
-    
-    gems = nil
-    unless expression_string.empty?
-      gems = { }
-      parse_gem_names_from_expression_string( gems, expression_string )
-    end
-    
-    case enable_or_disable = enable_or_disable.to_sym
+      gem_directory_name = gem_name_or_path.to_s.gsub( '/', '-' )
+      gem_require_name = gem_name_or_path.to_s.gsub( '-', '/' )
+      
+      gem_reference_name = gem_directory_name.to_sym
       
-      when :enable
+      if @loaded_gems.has_key?( gem_reference_name )
         
-        if gems
-          gems.each do |this_gem_or_gemset, true_value|
-            if gemset = @gemsets[ this_gem_or_gemset ]
-              gemset.each do |this_gem, true_value|
-                @enabled_gems[ this_gem ] = true
-                @disabled_gems.delete( this_gem )
-              end
-            else
-              this_gem = this_gem_or_gemset
-              @enabled_gems[ this_gem ] = true
-              @disabled_gems.delete( this_gem )
-            end
-          end
-        else
-          @disabled_gems.delete_if do |this_gem, true_value|
-            @enabled_gems[ this_gem ] = true
-            true
+        did_load = false
+
+      else
+
+        # look for gem name in enabled gems/gemsets
+        if gem_instance = @gems[ gem_reference_name ]
+
+          if gem_instance.enabled?
+            load_gem_instance( gem_instance, gem_directory_name, gem_require_name )
+            did_load = true
+          elsif @enable_for_all && ! gem_instance.disabled?
+            did_load = attempt_load_from_general_load_paths( gem_directory_name, gem_require_name )
           end
-          @enable_for_all = true
+        
+        # otherwise see if we perform general loading
         end
         
-      when :disable
-
-        if gems
-          gems.each do |this_gem_or_gemset, true_value|
-            if gemset = @gemsets[ this_gem_or_gemset ]
-              gemset.each do |this_gem, true_value|
-                @disabled_gems[ this_gem ] = true
-                @enabled_gems.delete( this_gem )
-              end
-            else
-              this_gem = this_gem_or_gemset
-              @disabled_gems[ this_gem ] = true
-              @enabled_gems.delete( this_gem )
-            end
-          end
-        else
-          @enabled_gems.delete_if do |this_gem, true_value|
-            @disabled_gems[ this_gem ] = true
-            true
-          end 
-          @enable_for_all = false
+        if ! did_load and @enable_for_all
+          attempt_load_from_general_load_paths( gem_directory_name, gem_require_name )
         end
         
+      end
+      
     end
     
-    # do we have gems?
-    
-    return self
+    return did_load
     
   end
-
-  #############################################
-  #  self.parse_general_load_path_expression  #
-  #############################################
-
+  
+  ############################
+  #  self.load_gem_instance  #
+  ############################
+  
   ###
-  # Parse expression string that has been determined as a general directory expression.
+  # Load gem using configuration information provides by gem instance.
   #
-  # @param expression_string
+  # @param gem_instance
   #
-  #        String describing general directory expression.
+  #        Gem instance.
   #
-  # @return [Object] Self.
+  # @param gem_directory_name
   #
-  def self.parse_general_load_path_expression( expression_string )
-    
-    # path/to/directory, ~/path/to/directory, /path/to/directory
-    # +directory_name/path/from/directory
-    
-    case expression_string[ 0 ]
-      
-      when '@'
-
-        path_parts = expression_string.split( '/' )
-        named_directory = path_parts.shift
-        named_directory.slice!( 0, 1 )
-        named_directory = named_directory.to_sym
-        expression_string = ::File.expand_path( ::File.join( directory( named_directory ), path_parts ) )
-      
-    end
-    
-    @general_load_paths.push( ::File.expand_path( expression_string ) )
-    
-    return self
-    
-  end
-
-  ####################################################
-  #  self.parse_remove_general_load_path_expression  #
-  ####################################################
-  
-  ###
-  # Parse expression string that has been determined as a remove-general-directory expression.
+  #        Gem directory in hyphenated gem-subgem format.
   #
-  # @param expression_string
+  # @param gem_require_name
   #
-  #        String describing remove general directory expression.
+  #        Gem name in slashed gem/subgem format.
   #
-  # @return [Object] Self.
+  # @return [::Development] Self.
   #
-  def self.parse_remove_general_load_path_expression( expression_string )
+  def self.load_gem_instance( gem_instance, gem_directory_name, gem_require_name )
     
-    # -path/to/directory, -~/path/to/directory, -/path/to/directory
-    
-    expression_string.slice!( 0, 1 )
-    path_string = expression_string.dup
-    expression_string.clear
+    gem_location = gem_instance.directory.path
+
+    if path_is_gem_directory?( gem_location, gem_require_name )
+      # already set
+    elsif path_contains_gem_directory?( gem_location, gem_directory_name, gem_require_name )
+      gem_location = ::File.join( gem_location, gem_directory_name )
+    end
 
-    @general_load_paths.delete( ::File.expand_path( path_string ) )
+    load_gem_in_path( gem_location, gem_directory_name )
+    @loaded_gems[ gem_require_name.to_sym ] = true
     
     return self
     
   end
-
-  ##################
-  #  self.require  #
-  ##################
+  
+  ###############################################
+  #  self.attempt_load_from_general_load_paths  #
+  ###############################################
   
   ###
-  # Filters requires to match configuration specifications for loading development paths instead of production gems.
+  # Attempt to load gem from general load paths if any are provided.
   #
-  # @param gem_name_or_path
+  # @param gem_directory_name
   #
-  #        Gem name or path to file passed to {::Object#require}.
+  #        Gem directory in hyphenated gem-subgem format.
   #
-  # @return [true,false] Whether Development handled gem_name_or_path (true) or processing should continue (false).
+  # @param gem_require_name
   #
-  def self.require( gem_name_or_path )
+  #        Gem name in slashed gem/subgem format.
+  #
+  # @return [::Development] Self.
+  #
+  def self.attempt_load_from_general_load_paths( gem_directory_name, gem_require_name )
     
-    did_load = nil
+    gem_require_name = gem_directory_name.to_sym
+    
+    did_load = false
+    
+    # look in each path for gem - use first to match
+    @general_load_paths.each do |this_load_path|
 
-    # if our path ends with an extension we are not requiring a gem and thus not responsible for managing it
-    if ::File.extname( gem_name_or_path ).empty?
+      if path_is_gem_directory?( this_load_path, gem_require_name )
 
-      gem_name = gem_name_or_path.to_s
+        load_gem_in_path( this_load_path, gem_directory_name )
+        @loaded_gems[ gem_require_name ] = true
+        did_load = true
+        break
 
-      if @loaded_gems.has_key?( gem_name.to_sym )
-        did_load = false
-      else
-        # ensure we have 'gem-subname' rather than 'gem/subname'
-        # we really just need one or the other consistently
-        gem_name = gem_name.gsub( '/', '-' )
-        gem_directory_name = gem_name.gsub( '/', '-' )
+      elsif path_contains_gem_directory?( this_load_path, gem_directory_name, gem_require_name )
 
-        # look for gem name in enabled gems/gemsets
-        if @enabled_gems.include?( gem_name.to_sym ) or 
-           @enable_for_all && ! @disabled_gems.include?( gem_name.to_sym )
-
-          if directory_name = @gem_locations[ gem_name.to_sym ]
-
-            load_path = directory( directory_name )
-          
-            if gem_name_in_load_path?( load_path, gem_directory_name )
-          
-              load_gem_in_path( load_path, gem_directory_name )
-              @loaded_gems[ gem_name.to_sym ] = true
-              did_load = true
-          
-            elsif gem_name_at_load_path?( load_path, gem_directory_name )
-            
-              load_gem_at_path( load_path, gem_directory_name )
-              @loaded_gems[ gem_name.to_sym ] = true
-              did_load = true
-            
-            end
-                    
-          end
-    
-          unless did_load
-          
-            # look in each path for gem - use first to match
-            @general_load_paths.each do |this_load_path|
+        gem_location = ::File.join( this_load_path, gem_directory_name )
 
-              # look for gem name at load path
-              if gem_name_at_load_path?( this_load_path, gem_name )
-                load_gem_at_path( this_load_path, gem_name )
-                @loaded_gems[ gem_name.to_sym ] = true
-                did_load = true
-              end
+        load_gem_in_path( gem_location, gem_directory_name )
+        @loaded_gems[ gem_require_name ] = true
+        did_load = true
+        break
 
-            end
-      
-          end
-    
-        end
-        
       end
-      
+
     end
     
     return did_load
@@ -951,7 +621,7 @@ module ::Development
   end
 
   #################################
-  #  self.gem_name_in_load_path?  #
+  #  self.path_is_gem_directory?  #
   #################################
   
   ###
@@ -961,33 +631,29 @@ module ::Development
   #
   #        Path where gem directory might be located.
   #
-  # @param gem_directory_name 
+  # @param gem_require_name 
   #
   #        Name of gem. Assumes gem-subname is used rather than gem/subname.
   #
   # @return [true,false] Whether gem name is present.
   #
-  def self.gem_name_in_load_path?( gem_path, gem_directory_name, require_gem_at_path = false )
+  def self.path_is_gem_directory?( load_path, gem_require_name )
     
     exists_at_load_path = false
     
-    gem_name = gem_directory_name.gsub( '-', '/' )
-    
-    gem_require_file = ::File.join( gem_path, 'lib', gem_name ) + '.rb'
-    
+    gem_require_file = ::File.join( load_path, 'lib', gem_require_name ) + '.rb'
+
     if ::File.exist?( ::File.expand_path( gem_require_file ) )
-      
       exists_at_load_path = true
-    
     end
     
     return exists_at_load_path
     
   end
 
-  #################################
-  #  self.gem_name_at_load_path?  #
-  #################################
+  #######################################
+  #  self.path_contains_gem_directory?  #
+  #######################################
   
   ###
   # Query whether gem name is present at load path, meaning load path specifies the directory holding gem directory.
@@ -1000,17 +666,20 @@ module ::Development
   #
   #        Name of gem. Assumes gem-subname is used rather than gem/subname.
   #
+  # @param gem_require_name 
+  #
+  #        Name of gem. Assumes gem/subname is used rather than gem-subname.
+  #
   # @return [true,false] Whether gem name is present.
   #
-  def self.gem_name_at_load_path?( load_path, gem_directory_name, require_gem_at_path = false )
+  def self.path_contains_gem_directory?( load_path, gem_directory_name, gem_require_name )
     
     exists_at_load_path = false
     
-    gem_name = gem_directory_name.gsub( '-', '/' )
     gem_path = ::File.join( load_path, gem_directory_name )
     
-    gem_require_file = ::File.join( gem_path, 'lib', gem_name ) + '.rb'
-    
+    gem_require_file = ::File.join( gem_path, 'lib', gem_require_name ) + '.rb'
+
     if ::Dir.exist?( ::File.expand_path( gem_path ) ) and 
        ::File.exist?( ::File.expand_path( gem_require_file ) )
       
@@ -1039,69 +708,45 @@ module ::Development
   #
   # @return [true,false] Whether gem name is present.
   #
-  def self.load_gem_in_path( gem_path, gem_directory_name )
+  def self.load_gem_in_path( load_path, gem_directory_name )
         
-    gem_name = gem_directory_name.gsub( '-', '/' )
-    
-    gem_require_file = ::File.join( gem_path, 'lib', gem_name ) + '.rb'
+    gem_require_file = ::File.join( load_path, 'lib', gem_directory_name ) + '.rb'
     require_relative( ::File.expand_path( gem_require_file ) )
     
   end
-  
-  ###########################
-  #  self.load_gem_at_path  #
-  ###########################
+
+  ##################################
+  #  self.load_configuration_file  #
+  ##################################
   
   ###
-  # Load gem from path to directory holding gem directory. Assumes gem is present at path.
-  #
-  # @param load_path 
+  # Load Development configuration file.
   #
-  #        Path where gem directory might be located.
-  #
-  # @param gem_directory_name 
+  # @param path 
   #
-  #        Name of gem. Assumes gem-subname is used rather than gem/subname.
+  #        Location of configuration file.
   #
-  # @return [true,false] Whether gem name is present.
+  # @return [::Development] Self.
   #
-  def self.load_gem_at_path( load_path, gem_directory_name )
-        
-    gem_name = gem_directory_name.gsub( '-', '/' )
-    gem_path = ::File.join( load_path, gem_directory_name )
+  def self.load_configuration_file( path )
     
-    gem_require_file = ::File.join( gem_path, 'lib', gem_name ) + '.rb'
+    absolute_path = ::File.expand_path( path )
     
-    require_relative( ::File.expand_path( gem_require_file ) )
+    if ::File.exists?( absolute_path )
+      ::Development::ConfigurationInterface.module_eval do
+        alias_method :gem, :gem_method
+      end
+      load( absolute_path )
+      ::Development::ConfigurationInterface.module_eval do
+        remove_method :gem
+      end
+    end
+    
+    return self
     
   end
   
 end
 
-require_relative 'development/require.rb'
-
-require_relative 'development/exception/expression_error.rb'
-require_relative 'development/exception/expression_error/unknown_directory_name.rb'
-require_relative 'development/exception/expression_error/unknown_gem_or_gemset_name.rb'
-
-require_relative 'development/exception/malformed_expression.rb'
-require_relative 'development/exception/malformed_expression/malformed_named_directory_expression.rb'
-require_relative 'development/exception/malformed_expression/malformed_gemset_expression.rb'
-require_relative 'development/exception/malformed_expression/malformed_location_expression.rb'
-require_relative 'development/exception/malformed_expression/malformed_enable_disable_expression.rb'
-require_relative 'development/exception/malformed_expression/malformed_general_directory_expression.rb'
-require_relative 'development/exception/malformed_expression/malformed_remove_general_directory_expression.rb'
-
-###
-# Object is enabled with Development require functionality.
-#
-class ::Object
-  include ::Development::Require
-  extend ::Development::Require
-end
-
-if defined?( ::Bundler )
-  ::Development::Require::BundlerSupport.call
-end
-
-::Development.load_configuration_file( ::File.join( '~', ::Development::ConfigurationFileName ) )
+# post-load setup
+require_relative './setup.rb'