ginjo-rfm 3.0.9 → 3.0.10

data/lib/rfm/server.rb

@@ -1,5 +1,6 @@
 require 'net/https'
 require 'cgi'
+
 module Rfm
   # This class represents a single FileMaker server. It is initialized with basic
   # connection information, including the hostname, port number, and default database
@@ -45,9 +46,9 @@ module Rfm
   # * *host_name* is the host name this server points to
   # * *port* is the port number this server communicates on
   # * *state* is a hash of all server options used to initialize this server
-  
-  
-  
+
+
+
   # The Database object represents a single FileMaker Pro database. When you retrieve a Database
   # object from a server, its account name and password are set to the account name and password you 
   # used when initializing the Server object. You can override this of course:
@@ -108,8 +109,8 @@ module Rfm
   # * *state* is a hash of all server options used to initialize this server
   class Server
     include Config
-    
-  
+
+
     # To create a Server object, you typically need at least a host name:
     # 
     #   myServer = Rfm::Server.new({:host => 'my.host.com'})
@@ -195,11 +196,11 @@ module Rfm
     #            :root_cert_path => '/usr/cert_file/'
     #            })
     def initialize(*args)
-    	config(*args)
-    	raise Rfm::Error::RfmError.new(0, "New instance of Rfm::Server has no host name. Attempted name '#{state[:host]}'.") if state[:host].to_s == ''
+      config(*args)
+      raise Rfm::Error::RfmError.new(0, "New instance of Rfm::Server has no host name. Attempted name '#{state[:host]}'.") if state[:host].to_s == ''
       @databases = Rfm::Factory::DbFactory.new(self)
     end
-   	
+
     # Access the database object representing a database on the server. For example:
     #
     #   myServer['Customers']
@@ -212,25 +213,32 @@ module Rfm
     # get no error at this point if the database you access doesn't exist. Instead, you'll
     # receive an error when you actually try to perform some action on a layout from this
     # database.
-		#     def [](dbname, acnt=nil, pass=nil)
-		#       self.db[dbname, acnt, pass]
-		#     end
+    #     def [](dbname, acnt=nil, pass=nil)
+    #       self.db[dbname, acnt, pass]
+    #     end
     def_delegator :databases, :[]
-    
+
     attr_reader :databases #, :host_name, :port, :scheme, :state
     # Legacy Rfm method to get/create databases from server object
     alias_method :db, :databases
-    
+
     def config(*args)
-    	super(:capture_strings_with=>[:host, :account_name, :password]) 
-    	super(*args)
+      super(:capture_strings_with=>[:host, :account_name, :password])
+      super(*args)
     end
- 
-    
-	  def host_name; state[:host]; end
-	  def scheme; state[:ssl] ? "https" : "http"; end
-	  def port; state[:ssl] && state[:port].nil? ? 443 : state[:port]; end
-    
+
+    def host_name
+      state[:host]
+    end
+
+    def scheme
+      state[:ssl] ? "https" : "http"
+    end
+
+    def port
+      state[:ssl] && state[:port].nil? ? 443 : state[:port]
+    end
+
     # Performs a raw FileMaker action. You will generally not call this method directly, but it
     # is exposed in case you need to do something "under the hood."
     # 
@@ -258,6 +266,6 @@ module Rfm
     #     },
     #     { :max_records => 20 }
     #   )
-    
+
   end
-end
+end

data/lib/rfm/utilities/case_insensitive_hash.rb

@@ -1,10 +1,13 @@
 module Rfm
   class CaseInsensitiveHash < Hash
+
     def []=(key, value)
       super(key.to_s.downcase, value)
     end
+
     def [](key)
       super(key.to_s.downcase)
     end
+
   end
-end
+end

data/lib/rfm/utilities/compound_query.rb

@@ -1,114 +1,113 @@
 # The classes in this module are used internally by RFM and are not intended for outside use.
 module Rfm
 
-
-	# Class to build complex FMP queries.
-	# Perform Filemaker find using complex boolean logic (multiple value options for a single field),
-	# or create multiple find requests.
-	# Also allow find requests to be :omit.
+  # Class to build complex FMP queries.
+  # Perform Filemaker find using complex boolean logic (multiple value options for a single field),
+  # or create multiple find requests.
+  # Also allow find requests to be :omit.
   class CompoundQuery < Array
-  
-  	attr_accessor :original_input, :query_type, :key_values, :key_arrays, :key_map, :key_map_string, :key_counter, :field_mapping
-  	
-  	def self.build_test
-  		new([{:field1=>['val1a','val1b','val1c'], :field2=>'val2'},{:omit=>true, :field3=>'val3', :field4=>'val4'}, {:omit=>true, :field5=>['val5a','val5b'], :field6=>['val6a','val6b']}], {})
-  	end
-  	
-  	# New CompoundQuery objects expect one of 3 data types:
-  	# * string/integer representing FMP internal record id
-  	# * hash of find-criteria
-  	# * array of find-criteria hashes
-  	#
-  	# Returns self as ['-fmpaction', {:hash=>'of', :key=>'values'}, {:options=>'hash'}]
-  	def initialize(query, options={})
-  		@options = options
-  		@field_mapping = options.delete(:field_mapping) || {}
-  		@original_input = query
-			@key_values = {}
-			@key_arrays = []
-			@key_map = []
-			@key_map_string = ''
-			@key_counter = 0
 
-  		case query
-			when Hash
-				if query.detect{|k,v| v.kind_of? Array or k == :omit}
-					@query_type = 'mixed'
-				else
-					@query_type = 'standard'
-				end
-			when Array
-				@query_type = 'compound'
-			else
-				@query_type = 'recid'
-			end
-			build_query
-  	end
+    attr_accessor :original_input, :query_type, :key_values, :key_arrays, :key_map, :key_map_string, :key_counter, :field_mapping
+
+    def self.build_test
+      new([{:field1=>['val1a','val1b','val1c'], :field2=>'val2'},{:omit=>true, :field3=>'val3', :field4=>'val4'}, {:omit=>true, :field5=>['val5a','val5b'], :field6=>['val6a','val6b']}], {})
+    end
+
+    # New CompoundQuery objects expect one of 3 data types:
+    # * string/integer representing FMP internal record id
+    # * hash of find-criteria
+    # * array of find-criteria hashes
+    #
+    # Returns self as ['-fmpaction', {:hash=>'of', :key=>'values'}, {:options=>'hash'}]
+    def initialize(query, options={})
+      @options = options
+      @field_mapping = options.delete(:field_mapping) || {}
+      @original_input = query
+      @key_values = {}
+      @key_arrays = []
+      @key_map = []
+      @key_map_string = ''
+      @key_counter = 0
+
+      case query
+      when Hash
+        if query.detect{|k,v| v.kind_of? Array or k == :omit}
+          @query_type = 'mixed'
+        else
+          @query_type = 'standard'
+        end
+      when Array
+        @query_type = 'compound'
+      else
+        @query_type = 'recid'
+      end
+      build_query
+    end
+
+    # Master control method to build output
+    def build_query(input=original_input)
+      case @query_type
+      when 'mixed', 'compound'
+        input.rfm_force_array.each do |hash|
+          build_key_map(build_key_values(hash))
+        end
+        translate_key_map
+        self.push '-findquery'
+        self.push @key_values.merge('-query'=>@key_map_string)
+      when 'standard'
+        self.push '-find'
+        self.push @original_input
+      when 'recid'
+        self.push '-find'
+        self.push '-recid' => @original_input.to_s
+      end
+      self.push @options
+      self
+    end
 
-		# Master control method to build output
-  	def build_query(input=original_input)
-  		case @query_type
-	  	when 'mixed', 'compound'
-	  		input.rfm_force_array.each do |hash|
-	  			build_key_map(build_key_values(hash))
-	  		end
-	  		translate_key_map
-	  		self.push '-findquery'
-	  		self.push @key_values.merge('-query'=>@key_map_string)
-	  	when 'standard'
-	  		self.push '-find'
-	  		self.push @original_input
-	  	when 'recid'
-	  		self.push '-find'
-	  		self.push '-recid' => @original_input.to_s
-	  	end
-	  	self.push @options
-	  	self
-  	end
 
+    # Build key-value definitions and query map  '-q1...'.
+    # Converts query_hash to fmresultset uri format for -findquery query type.
+    def build_key_values(input_hash)
+      input_hash = input_hash.clone
+      keyarray = []
+      omit = input_hash.delete(:omit)
+      input_hash.each do |key,val|
+        query_tag = []
+        val = val.rfm_force_array
+        val.each do |v|
+          @key_values["-q#{key_counter}"] = field_mapping[key] || key
+          @key_values["-q#{key_counter}.value"] = v
+          query_tag << "q#{key_counter}"
+          @key_counter += 1
+        end
+        keyarray << query_tag
+      end
+      (keyarray << :omit) if omit
+      @key_arrays << keyarray
+      keyarray
+    end
 
-		# Build key-value definitions and query map  '-q1...'.
-		# Converts query_hash to fmresultset uri format for -findquery query type.
-		def build_key_values(input_hash)
-			input_hash = input_hash.clone
-			keyarray = []
-			omit = input_hash.delete(:omit)
-			input_hash.each do |key,val|
-				query_tag = []
-				val = val.rfm_force_array
-				val.each do |v|
-					@key_values["-q#{key_counter}"] = field_mapping[key] || key
-					@key_values["-q#{key_counter}.value"] = v
-					query_tag << "q#{key_counter}"
-					@key_counter += 1
-				end
-				keyarray << query_tag
-			end
-			(keyarray << :omit) if omit
-			@key_arrays << keyarray
-			keyarray
-		end
 
-		
-		# Input array of arrays.
-		# Transform single key_array into key_map (array of requests).
-		# Creates all combinations of sub-arrays where each combination contains one element of each subarray.
-		def build_key_map(key_array)
-			key_array = key_array.clone
-			omit = key_array.delete(:omit)
-			len = key_array.length
-			flat = key_array.flatten
-			rslt = flat.combination(len).select{|c| key_array.all?{|a| (a & c).size > 0}}.each{|c| c.unshift(:omit) if omit}
-			@key_map.concat rslt
-		end
+    # Input array of arrays.
+    # Transform single key_array into key_map (array of requests).
+    # Creates all combinations of sub-arrays where each combination contains one element of each subarray.
+    def build_key_map(key_array)
+      key_array = key_array.clone
+      omit = key_array.delete(:omit)
+      len = key_array.length
+      flat = key_array.flatten
+      rslt = flat.combination(len).select{|c| key_array.all?{|a| (a & c).size > 0}}.each{|c| c.unshift(:omit) if omit}
+      @key_map.concat rslt
+    end
 
-		# Translate @key_map to FMP -query string
-		def translate_key_map(keymap=key_map)
-			keymap = keymap.clone
-			inner = keymap.collect {|a| "#{'!' if a.delete(:omit)}(#{a.join(',')})"}
-			outter = inner.join(';')
-			@key_map_string << outter
-		end
+    # Translate @key_map to FMP -query string
+    def translate_key_map(keymap=key_map)
+      keymap = keymap.clone
+      inner = keymap.collect {|a| "#{'!' if a.delete(:omit)}(#{a.join(',')})"}
+      outter = inner.join(';')
+      @key_map_string << outter
+    end
 
   end # CompoundQuery
 

data/lib/rfm/utilities/config.rb

@@ -1,232 +1,242 @@
 module Rfm
-	#
-	# Top level config hash accepts any defined config parameters,
-	# or group-name keys pointing to config subsets.
-	# The subsets can be any grouping of defined config parameters, as a hash.
-	# See CONFIG_KEYS for defined config parameters.
-	#
+  #
+  # Top level config hash accepts any defined config parameters,
+  # or group-name keys pointing to config subsets.
+  # The subsets can be any grouping of defined config parameters, as a hash.
+  # See CONFIG_KEYS for defined config parameters.
+  #
   module Config
-  	require 'yaml'
-  	require 'erb'
-  	
-		CONFIG_KEYS = %w(
-			file_name
-			file_path
-			parser
-			host
-			port
-			proxy
-			account_name
-			password
-			database
-			layout
-			ignore_bad_data
-			ssl
-			root_cert
-			root_cert_name
-			root_cert_path
-			warn_on_redirect
-			raise_on_401
-			timeout
-			log_actions
-			log_responses
-			log_parser
-			use
-			parent
-			template
-			grammar
-			field_mapping
-			capture_strings_with
-			logger
-		)
-		
-		CONFIG_DONT_STORE = %w(strings using parents symbols objects)  #capture_strings_with)
-  	
+    require 'yaml'
+    require 'erb'
+
+    CONFIG_KEYS = %w(
+      file_name
+      file_path
+      parser
+      host
+      port
+      proxy
+      account_name
+      password
+      database
+      layout
+      ignore_bad_data
+      ssl
+      root_cert
+      root_cert_name
+      root_cert_path
+      warn_on_redirect
+      raise_on_401
+      timeout
+      log_actions
+      log_responses
+      log_parser
+      use
+      parent
+      template
+      grammar
+      field_mapping
+      capture_strings_with
+      logger
+    )
+
+    CONFIG_DONT_STORE = %w(strings using parents symbols objects)  #capture_strings_with)
+
     extend self
     @config = {}
-	  	  
-	  # Set @config with args & options hash.
-	  # Args should be symbols representing configuration groups,
-	  # with optional config hash as last arg, to be merged on top.
-	  # Returns @config.
-	  #
-	  # == Sets @config with :use => :group1, :layout => 'my_layout'
-	  #    config :group1, :layout => 'my_layout
-	  #
-	  # Factory.server, Factory.database, Factory.layout, and Base.config can take
-	  # a string as the first argument, refering to the relevent server/database/layout name.
-	  #
-	  # == Pass a string as the first argument, to be used in the immediate context
-	  #    config 'my_layout'                     # in the model, to set model configuration
-	  #    Factory.layout 'my_layout', :my_group  # to get a layout from settings in :my_group
-	  #
-	  def config(*args, &block)
-	  	@config ||= {}
-	  	return @config if args.empty?
-			config_write(*args, &block)
-			@config
-	  end
-	  
-	  # Sets @config just as above config method, but clears @config first.
-	  def config_clear(*args)
-	  	@config = {}
-	  	return @config if args.empty?
-			config_write(*args)
-			@config
-	  end
-	  
-	  # Reads compiled config, including filters and ad-hoc configuration params passed in.
-	  # If first n parameters are strings, they will be appended to config[:strings].
-	  # If next n parameters are symbols, they will be used to filter the result. These
-	  # filters will override all stored config[:use] settings.
-	  # The final optional hash should be ad-hoc config settings.
-	  #
-	  # == Gets top level settings, merged with group settings, merged with local and ad-hoc settings.
-	  #    get_config :my_server_group, :layout => 'my_layout'  # This gets top level settings,
-		#
-		# == Gets top level settings, merged with local and ad-hoc settings.
-		#    get_config :layout => 'my_layout
-		#
-  	def get_config(*arguments)
-  		#puts caller_locations(1,1)[0]
-  		args = arguments.clone
-  		@config ||= {}
-  		options = config_extract_options!(*args)
-  		strings = options[:strings].rfm_force_array || []
-  		symbols = options[:symbols].rfm_force_array.concat(options[:hash][:use].rfm_force_array) || []
-  		objects = options[:objects].rfm_force_array || []
-
-			rslt = config_merge_with_parent(symbols).merge(options[:hash])
-			#using = rslt[:using].rfm_force_array
-			sanitize_config(rslt, CONFIG_DONT_STORE, false)
-			rslt[:using].delete ""
-			rslt[:parents].delete ""
-			rslt.merge(:strings=>strings, :objects=>objects)
-  	end
-  	
-		def state(*args)
-			return @_state if args.empty? && !@state.nil? && (RUBY_VERSION[0,1].to_i > 1 ? (caller_locations(1,1) == @_last_state_caller) : false)
-			@_state = get_config(*args)
-			(@_last_state_caller = caller_locations(1,1)) if RUBY_VERSION[0,1].to_i > 1
-			@_state
-		end
-		
-		def log
-			Rfm.log
-		end
-  		  
-	protected
-	
-		# Get or load a config file as the top-level config (above RFM_CONFIG constant).
-		# Default file name is rfm.yml.
-		# Default paths are '' and 'config/'.
-		# File name & paths can be set in RFM_CONFIG and Rfm.config.
-		# Change file name with :file_name => 'something.else'
-		# Change file paths with :file_path => ['array/of/', 'file/paths/']
-		def get_config_file
-			@@config_file_data ||= (
-				config_file_name = @config[:file_name] || (RFM_CONFIG[:file_name] rescue nil) || 'rfm.yml'
-				config_file_paths = [''] | [(@config[:file_path] || (RFM_CONFIG[:file_path] rescue nil) || %w( config/ ./ ))].flatten
-				config_file_paths.collect do |path|
-					(YAML.load(ERB.new(File.read(File.join(path, config_file_name))).result) rescue {})
-				end.inject({}){|h,a| h.merge(a)}
-			) || {}
-		end
-		
-		# Get the top-level configuration from yml file and RFM_CONFIG
-		def get_config_base
-			get_config_file.merge((defined?(RFM_CONFIG) and RFM_CONFIG.is_a?(Hash)) ? RFM_CONFIG : {})
-		end
-
-		# Get the parent configuration object according to @config[:parent]
+
+    # Set @config with args & options hash.
+    # Args should be symbols representing configuration groups,
+    # with optional config hash as last arg, to be merged on top.
+    # Returns @config.
+    #
+    # == Sets @config with :use => :group1, :layout => 'my_layout'
+    #    config :group1, :layout => 'my_layout
+    #
+    # Factory.server, Factory.database, Factory.layout, and Base.config can take
+    # a string as the first argument, refering to the relevent server/database/layout name.
+    #
+    # == Pass a string as the first argument, to be used in the immediate context
+    #    config 'my_layout'                     # in the model, to set model configuration
+    #    Factory.layout 'my_layout', :my_group  # to get a layout from settings in :my_group
+    #
+    def config(*args, &block)
+      @config ||= {}
+      return @config if args.empty?
+      config_write(*args, &block)
+      @config
+    end
+
+    # Sets @config just as above config method, but clears @config first.
+    def config_clear(*args)
+      @config = {}
+      return @config if args.empty?
+      config_write(*args)
+      @config
+    end
+
+    # Reads compiled config, including filters and ad-hoc configuration params passed in.
+    # If first n parameters are strings, they will be appended to config[:strings].
+    # If next n parameters are symbols, they will be used to filter the result. These
+    # filters will override all stored config[:use] settings.
+    # The final optional hash should be ad-hoc config settings.
+    #
+    # == Gets top level settings, merged with group settings, merged with local and ad-hoc settings.
+    #    get_config :my_server_group, :layout => 'my_layout'  # This gets top level settings,
+    #
+    # == Gets top level settings, merged with local and ad-hoc settings.
+    #    get_config :layout => 'my_layout
+    #
+    def get_config(*arguments)
+      #puts caller_locations(1,1)[0]
+      args = arguments.clone
+      @config ||= {}
+      options = config_extract_options!(*args)
+      strings = options[:strings].rfm_force_array || []
+      symbols = options[:symbols].rfm_force_array.concat(options[:hash][:use].rfm_force_array) || []
+      objects = options[:objects].rfm_force_array || []
+
+      rslt = config_merge_with_parent(symbols).merge(options[:hash])
+      #using = rslt[:using].rfm_force_array
+      sanitize_config(rslt, CONFIG_DONT_STORE, false)
+      rslt[:using].delete ""
+      rslt[:parents].delete ""
+      rslt.merge(:strings=>strings, :objects=>objects)
+    end
+
+    def state(*args)
+      return @_state if args.empty? && !@state.nil? && (RUBY_VERSION[0,1].to_i > 1 ? (caller_locations(1,1) == @_last_state_caller) : false)
+      @_state = get_config(*args)
+      (@_last_state_caller = caller_locations(1,1)) if RUBY_VERSION[0,1].to_i > 1
+      @_state
+    end
+
+    def log
+      Rfm.log
+    end
+
+    protected
+
+    # Get or load a config file as the top-level config (above RFM_CONFIG constant).
+    # Default file name is rfm.yml.
+    # Default paths are '' and 'config/'.
+    # File name & paths can be set in RFM_CONFIG and Rfm.config.
+    # Change file name with :file_name => 'something.else'
+    # Change file paths with :file_path => ['array/of/', 'file/paths/']
+    def get_config_file
+      @@config_file_data ||= (
+        config_file_name = @config[:file_name] || (RFM_CONFIG[:file_name] rescue nil) || 'rfm.yml'
+        config_file_paths = [''] | [(@config[:file_path] || (RFM_CONFIG[:file_path] rescue nil) || %w( config/ ./ ))].flatten
+        config_file_paths.collect do |path|
+          (YAML.load(ERB.new(File.read(File.join(path, config_file_name))).result) rescue {})
+        end.inject({}){|h,a| h.merge(a)}
+      ) || {}
+    end
+
+    # Get the top-level configuration from yml file and RFM_CONFIG
+    def get_config_base
+      get_config_file.merge((defined?(RFM_CONFIG) and RFM_CONFIG.is_a?(Hash)) ? RFM_CONFIG : {})
+    end
+
+    # Get the parent configuration object according to @config[:parent]
     def get_config_parent
-    	@config ||= {}
-	  	parent = case
-	  		when @config[:parent].is_a?(String); eval(@config[:parent])
-	  		when !@config[:parent].nil? && @config[:parent].is_a?(Rfm::Config); @config[:parent]
-	  		else eval('Rfm::Config')
-	  	end
-	  end	  
-	  
-		# Merge args into @config, as :use=>[arg1, arg2, ...]
-		# Then merge optional config hash into @config.
-		# Pass in a block to use with parsed config in args.
-	  def config_write(*args)   #(opt, args)
-	  	options = config_extract_options!(*args)
-	  	options[:symbols].each{|a| @config.merge!(:use=>a.to_sym){|h,v1,v2| [v1].flatten << v2  }}
-	  	@config.merge!(options[:hash]).reject! {|k,v| CONFIG_DONT_STORE.include? k.to_s}
-	  	#options[:hash][:capture_strings_with].rfm_force_array.each do |label|
-	  	@config[:capture_strings_with].rfm_force_array.each do |label|
-	  		string = options[:strings].delete_at(0)
-	  		(@config[label] = string) if string && !string.empty?
-	  	end
-	  	parent = (options[:objects].delete_at(0) || options[:hash][:parent])
-  		(@config[:parent] = parent) if parent
-	  	yield(options) if block_given?
-	  end
-	  	
-	  # Get composite config from all levels, processing :use parameters at each level
-	  def config_merge_with_parent(filters=nil)
-	  	@config ||= {}
-	  	
-	  	# Get upstream compilation
+      @config ||= {}
+      case
+      when @config[:parent].is_a?(String)
+        eval(@config[:parent])
+      when !@config[:parent].nil? && @config[:parent].is_a?(Rfm::Config)
+        @config[:parent]
+      else
+        eval('Rfm::Config')
+      end
+    end
+
+    # Merge args into @config, as :use=>[arg1, arg2, ...]
+    # Then merge optional config hash into @config.
+    # Pass in a block to use with parsed config in args.
+    def config_write(*args)   #(opt, args)
+      options = config_extract_options!(*args)
+      options[:symbols].each{|a| @config.merge!(:use=>a.to_sym){|h,v1,v2| [v1].flatten << v2  }}
+      @config.merge!(options[:hash]).reject! {|k,v| CONFIG_DONT_STORE.include? k.to_s}
+      #options[:hash][:capture_strings_with].rfm_force_array.each do |label|
+      @config[:capture_strings_with].rfm_force_array.each do |label|
+        string = options[:strings].delete_at(0)
+        (@config[label] = string) if string && !string.empty?
+      end
+      parent = (options[:objects].delete_at(0) || options[:hash][:parent])
+      (@config[:parent] = parent) if parent
+      yield(options) if block_given?
+    end
+
+    # Get composite config from all levels, processing :use parameters at each level
+    def config_merge_with_parent(filters=nil)
+      @config ||= {}
+
+      # Get upstream compilation
       upstream = if (self != Rfm::Config)
-      	#puts [self, @config[:parent], get_config_parent].join(', ')
-      	get_config_parent.config_merge_with_parent
+        #puts [self, @config[:parent], get_config_parent].join(', ')
+        get_config_parent.config_merge_with_parent
       else
-      	get_config_base
+        get_config_base
       end.clone
-            
+
       upstream[:using] ||= []
       upstream[:parents] ||= ['file', 'RFM_CONFIG']
 
-			filters = (@config[:use].rfm_force_array | filters.rfm_force_array).compact
+      filters = (@config[:use].rfm_force_array | filters.rfm_force_array).compact
+
+      rslt = config_filter(upstream, filters).merge(config_filter(@config, filters))
 
-			rslt = config_filter(upstream, filters).merge(config_filter(@config, filters))
+      rslt[:using].concat((@config[:use].rfm_force_array | filters).compact.flatten)   #.join
+      rslt[:parents] << @config[:parent].to_s
 
-			rslt[:using].concat((@config[:use].rfm_force_array | filters).compact.flatten)   #.join
-			rslt[:parents] << @config[:parent].to_s
-			
-			rslt.delete :parent
-			
-			rslt || {}
-# 		rescue
-# 			puts "Config#config_merge_with_parent for '#{self.class}' falied with #{$1}"
+      rslt.delete :parent
+
+      rslt || {}
+      #     rescue
+      #       puts "Config#config_merge_with_parent for '#{self.class}' falied with #{$1}"
+    end
+
+    # Returns a configuration hash overwritten by :use filters in the hash
+    # that match passed-in filter names or any filter names contained within the hash's :use key.
+    def config_filter(conf, filters=nil)
+      conf = conf.clone
+      filters = (conf[:use].rfm_force_array | filters.rfm_force_array).compact
+      if (!filters.nil? && !filters.empty?)
+        filters.each do |f|
+          next unless conf[f]
+          conf.merge!(conf[f] || {})
+        end
+      end
+      conf.delete(:use)
+      conf
+    end
+
+    # Extract arguments into strings, symbols, objects, hash.
+    def config_extract_options!(*args)
+      strings, symbols, objects = [], [], []
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      args.each do |a|
+        case
+        when a.is_a?(String)
+          strings << a
+        when a.is_a?(Symbol)
+          symbols << a
+        else
+          objects << a
+        end
+      end
+      {:strings=>strings, :symbols=>symbols, :objects=>objects, :hash=>options}
     end
-     
-		# Returns a configuration hash overwritten by :use filters in the hash
-		# that match passed-in filter names or any filter names contained within the hash's :use key.
-		def config_filter(conf, filters=nil)
-			conf = conf.clone
-			filters = (conf[:use].rfm_force_array | filters.rfm_force_array).compact
-			filters.each{|f| next unless conf[f]; conf.merge!(conf[f] || {})} if (!filters.nil? && !filters.empty?)
-			conf.delete(:use)
-			conf
-		end
-		
-		# Extract arguments into strings, symbols, objects, hash.
-		def config_extract_options!(*args)
-			strings, symbols, objects = [], [], []
-			options = args.last.is_a?(Hash) ? args.pop : {}
-			args.each do |a|
-				case
-				when a.is_a?(String); strings << a
-				when a.is_a?(Symbol); symbols << a
-				else objects << a
-				end
-			end
-			{:strings=>strings, :symbols=>symbols, :objects=>objects, :hash=>options}
-		end
-		
-		# Remove un-registered keys from a configuration hash.
-  	# Keep should be a list of strings representing keys to keep.
-  	def sanitize_config(conf={}, keep=[], dupe=false)
-  		(conf = conf.clone) if dupe
-  		conf.reject!{|k,v| (!CONFIG_KEYS.include?(k.to_s) or [{},[],''].include?(v)) and !keep.include? k.to_s }
-  		conf
-  	end
-
-
-	end # module Config
-	
-end # module Rfm
+
+    # Remove un-registered keys from a configuration hash.
+    # Keep should be a list of strings representing keys to keep.
+    def sanitize_config(conf={}, keep=[], dupe=false)
+      (conf = conf.clone) if dupe
+      conf.reject!{|k,v| (!CONFIG_KEYS.include?(k.to_s) or [{},[],''].include?(v)) and !keep.include? k.to_s }
+      conf
+    end
+
+  end # module Config
+
+end # module Rfm