ginjo-rfm 2.1.7 → 3.0.0

data/lib/rfm/resultset.rb

@@ -38,15 +38,21 @@ module Rfm
   class Resultset < Array
   	include Config
     
-    attr_reader :layout, :database, :server, :caller, :doc
-    attr_reader :field_meta, :portal_meta, :include_portals, :datasource
-    attr_reader :date_format, :time_format, :timestamp_format
-    attr_reader :total_count, :foundset_count, :table
+    attr_reader :layout, :meta, :calling_object
+#     attr_reader :layout, :database, :server, :calling_object, :doc
+#     attr_reader :field_meta, :portal_meta, :include_portals, :datasource
+#     attr_reader :date_format, :time_format, :timestamp_format
+#     attr_reader :total_count, :foundset_count, :table
     #def_delegators :layout, :db, :database
-    alias_method :db, :database
+    # alias_method :db, :database
+		def_delegators :meta, :field_meta, :portal_meta, :date_format, :time_format, :timestamp_format, :total_count, :foundset_count, :fetch_size, :table, :error, :field_names, :field_keys, :portal_names
+
     
     class << self
-    	alias_method :load_data, :new
+    	def load_data(data)
+    		Rfm::Connection
+    		Rfm::SaxParser.parse(data, :fmresultset, Rfm::Resultset.new)
+    	end
     end
     
     # Initializes a new ResultSet object. You will probably never do this your self (instead, use the Layout
@@ -70,122 +76,67 @@ module Rfm
     # * *portals* is a hash (with table occurrence names for keys and Field objects for values). If your
     #   layout contains portals, you can find out what fields they contain here. Again, if it's the data you're
     #   after, you want to look at the Record object.
-    def initialize(*args) # xml_response, caller, portals
-    	#Was (server_obj, xml_response, layout_obj, portals=nil)
-    	
-    	options = args.rfm_extract_options!      
-      config :parent=>'caller'
-      config sanitize_config(options, {}, true)
-      
-      xml_response			= args[0] || options[:xml_response]
-      doc = XmlParser.parse(xml_response, :namespace=>false, :parser=>(state[:parser] rescue nil))
-      
-      error = doc.error
-      check_for_errors(error, (server.state[:raise_on_401] rescue nil))
-      
-      @doc							= doc
-			@caller						= args[1] || options[:caller]
-      @layout           = (@caller.class.ancestors.include? Rfm::Layout::LayoutModule) ? @caller : options[:layout_object]
-      @database					= (@layout.database rescue nil) || (@caller.class == Rfm::Database ? @caller : options[:database_object])
-      @server           = (@database.server rescue nil) || (@caller.class == Rfm::Server ? @caller : options[:server_object])
-      @field_meta     ||= Rfm::CaseInsensitiveHash.new
-      @portal_meta    ||= Rfm::CaseInsensitiveHash.new
-      @include_portals  = args[2] || options[:include_portals]            
-
-      @datasource       = doc.datasource
-      meta              = doc.meta
-      resultset         = doc.resultset
+    def initialize(*args) # parent, layout
+			config *args
+			self.meta
+    end # initialize
 
-      @date_format      = doc.date_format
-      @time_format      = doc.time_format
-      @timestamp_format = doc.timestamp_format
-
-      @foundset_count   = doc.foundset_count
-      @total_count      = doc.total_count
-      @table            = doc.table
-            
-      (layout.table = @table) if layout and layout.table_no_load.blank?
-      
-      parse_fields(doc)
-      
-      # This will always load portal meta, even if :include_portals was not specified.
-      # See Record for control of portal data loading.
-      parse_portals(doc)
-      
-      # These were added for loading resultset from file
-      # Kind of a hack. This should ideally condense down to just another option on the main @layout = ...
-			#       unless @layout
-			#       	@layout = @datasource['layout']
-			#       	@layout.instance_variable_set '@database', @datasource['database']
-			#       	@layout.instance_eval do
-			#       		def database
-			#       			@database
-			#       		end
-			#       	end
-			#       end			
-      
-      return if doc.records.blank?
-      Rfm::Record.build_records(doc.records, self, @field_meta, @layout)
+    def config(*args)
+    	super do |params|
+    		(@layout = params[:objects][0]) if params &&
+    			params[:objects] &&
+    			params[:objects][0] &&
+    			params[:objects][0].is_a?(Rfm::Layout)
+    	end
     end
     
-    # Load Resultset data from file-spec or string
-		#     def self.load_data(file_or_string)
-		#     	self.new(file_or_string, nil)
-		#     end
-    
-		def state(*args)
-			get_config(*args)
+    # This method was added for situations where a layout was not provided at resultset instantiation,
+    # such as when loading a resultset from an xml file.
+    def layout
+    	@layout ||= (Layout.new(meta.layout, self) if meta.respond_to? :layout)
+    end
+		
+		def database
+			layout.database
+		end
+		
+		alias_method :db, :database
+		
+		def server
+			database.server
+		end
+		
+		def meta
+			# Access the meta inst var here.
+			@meta ||= Metadata::ResultsetMeta.new
 		end
-        
-    def field_names
-    	field_meta.collect{|k,v| v.name}
+
+  	def handle_new_record(attributes)
+  		r = Rfm::Record.new(self, attributes, {})
+  		self << r
+  		r
   	end
   	
-  	def portal_names
-  		portal_meta.keys
+  	def end_datasource_element_callback(cursor)
+  		%w(date_format time_format timestamp_format).each{|f| convert_date_time_format(eval(f))}
   	end
     
-    private
-    
-      def check_for_errors(code, raise_401)
-        raise Rfm::Error.getError(code) if code != 0 && (code != 401 || raise_401)
-      end
+  private
     
-      def parse_fields(doc)
-      	return if doc.fields.blank?
-
-        doc.fields.each do |field|
-        	name = layout.field_mapping[field.name] || field.name rescue field.name
-          @field_meta[name] = Rfm::Metadata::Field.new(field)
-        end
-        (layout.field_names = field_names) if layout and layout.field_names_no_load.blank?
-      end
-
-      def parse_portals(doc)
-      	return if doc.portals.blank?
-        doc.portals.each do |relatedset|
-        	next if relatedset.blank?
-          table, fields = relatedset.table, {}
-
-          relatedset.fields.each do |field|
-            name = field.name.to_s.gsub(Regexp.new(table + '::'), '')
-            fields[name] = Rfm::Metadata::Field.new(field)
-          end
+    def check_for_errors(code=@meta['error'].to_i, raise_401=state[:raise_401])
+    	#puts ["\nRESULTSET#check_for_errors", code, raise_401]
+      raise Rfm::Error.getError(code) if code != 0 && (code != 401 || raise_401)
+    end
 
-          @portal_meta[table] = fields
-        end
-        (layout.portal_meta = @portal_meta) if layout and layout.portal_meta_no_load.blank?
-      end
-    
-			#   def convert_date_time_format(fm_format)
-			#     fm_format.gsub!('MM', '%m')
-			#     fm_format.gsub!('dd', '%d')
-			#     fm_format.gsub!('yyyy', '%Y')
-			#     fm_format.gsub!('HH', '%H')
-			#     fm_format.gsub!('mm', '%M')
-			#     fm_format.gsub!('ss', '%S')
-			#     fm_format
-			#   end
+	  def convert_date_time_format(fm_format)
+	    fm_format.gsub!('MM', '%m')
+	    fm_format.gsub!('dd', '%d')
+	    fm_format.gsub!('yyyy', '%Y')
+	    fm_format.gsub!('HH', '%H')
+	    fm_format.gsub!('mm', '%M')
+	    fm_format.gsub!('ss', '%S')
+	    fm_format
+	  end
     
   end
 end

data/lib/rfm/server.rb

@@ -107,7 +107,6 @@ module Rfm
   # * *name* is the name of this database
   # * *state* is a hash of all server options used to initialize this server
   class Server
-    #extend Config
     include Config
     
   
@@ -196,31 +195,8 @@ module Rfm
     #            :root_cert_path => '/usr/cert_file/'
     #            })
     def initialize(*args)
-    	config :parent => 'Rfm::Config'
-    	options = get_config(*args)
-    	config sanitize_config(options, {}, true)
-    	config(:host => (options[:strings].delete_at(0) || options[:host]) )
-    	raise Rfm::Error::RfmError.new(0, "New instance of Rfm::Server has no host name. Attempted name '#{config[:host]}'.") if config[:host].to_s == ''
-      
-      @defaults = {
-        :host => 'localhost',
-        :port => 80,
-        :ssl => true,
-        :root_cert => true,
-        :root_cert_name => '',
-        :root_cert_path => '/',
-        :account_name => '',
-        :password => '',
-        :log_actions => false,
-        :log_responses => false,
-        :log_parser => false,
-        :warn_on_redirect => true,
-        :raise_on_401 => false,
-        :timeout => 60,
-        :ignore_bad_data => false,
-        :grammar => 'fmresultset'
-      }   #.merge(options)
-      
+    	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
    	
@@ -245,9 +221,11 @@ module Rfm
     # Legacy Rfm method to get/create databases from server object
     alias_method :db, :databases
     
-    def state(*args)
-    	@defaults.merge(get_config(*args))
+    def config(*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
@@ -280,150 +258,6 @@ module Rfm
     #     },
     #     { :max_records => 20 }
     #   )
-    def connect(account_name, password, action, args, options = {})
-    	grammar_option = options.delete(:grammar)
-      post = args.merge(expand_options(options)).merge({action => ''})
-      grammar = select_grammar(post, :grammar=>grammar_option)
-      http_fetch(host_name, port, "/fmi/xml/#{grammar}.xml", account_name, password, post)
-    end
-    
-    def load_layout(layout)
-      post = {'-db' => layout.db.name, '-lay' => layout.name, '-view' => ''}
-      resp = http_fetch(host_name, port, "/fmi/xml/FMPXMLLAYOUT.xml", layout.db.account_name, layout.db.password, post)
-      #remove_namespace(resp.body)
-    end
-    
-    def select_grammar(post, options={})
-			grammar = state(options)[:grammar] || 'fmresultset'
-			if grammar.to_s.downcase == 'auto'
-				post.keys.find(){|k| %w(-find -findall -dbnames -layoutnames -scriptnames).include? k.to_s} ? "FMPXMLRESULT" : "fmresultset"   
-    	else
-    		grammar
-    	end
-    end
-    
-    # Removes namespace from fmpxmllayout, so xpath will work
-  	def remove_namespace(xml)
-      xml.gsub(/xmlns=\"[^\"]*\"/, '')
-    end
-    
-    private
-    
-      def http_fetch(host_name, port, path, account_name, password, post_data, limit=10)
-        raise Rfm::CommunicationError.new("While trying to reach the Web Publishing Engine, RFM was redirected too many times.") if limit == 0
-    
-        if state[:log_actions] == true
-          #qs = post_data.collect{|key,val| "#{CGI::escape(key.to_s)}=#{CGI::escape(val.to_s)}"}.join("&")
-          qs_unescaped = post_data.collect{|key,val| "#{key.to_s}=#{val.to_s}"}.join("&")
-          #warn "#{@scheme}://#{@host_name}:#{@port}#{path}?#{qs}"
-          warn "#{scheme}://#{host_name}:#{port}#{path}?#{qs_unescaped}"
-        end
-    
-        request = Net::HTTP::Post.new(path)
-        request.basic_auth(account_name, password)
-        request.set_form_data(post_data)
-    
-        response = Net::HTTP.new(host_name, port)
-        #ADDED LONG TIMEOUT TIMOTHY TING 05/12/2011
-        response.open_timeout = response.read_timeout = state[:timeout]
-        if state[:ssl]
-          response.use_ssl = true
-          if state[:root_cert]
-            response.verify_mode = OpenSSL::SSL::VERIFY_PEER
-            response.ca_file = File.join(state[:root_cert_path], state[:root_cert_name])
-          else
-            response.verify_mode = OpenSSL::SSL::VERIFY_NONE
-          end
-        end
-    
-        response = response.start { |http| http.request(request) }
-        if state[:log_responses] == true
-          response.to_hash.each { |key, value| warn "#{key}: #{value}" }
-          warn response.body
-        end
-    
-        case response
-        when Net::HTTPSuccess
-          response
-        when Net::HTTPRedirection
-          if state[:warn_on_redirect]
-            warn "The web server redirected to " + response['location'] + 
-            ". You should revise your connection hostname or fix your server configuration if possible to improve performance."
-          end
-          newloc = URI.parse(response['location'])
-          http_fetch(newloc.host, newloc.port, newloc.request_uri, account_name, password, post_data, limit - 1)
-        when Net::HTTPUnauthorized
-          msg = "The account name (#{account_name}) or password provided is not correct (or the account doesn't have the fmxml extended privilege)."
-          raise Rfm::AuthenticationError.new(msg)
-        when Net::HTTPNotFound
-          msg = "Could not talk to FileMaker because the Web Publishing Engine is not responding (server returned 404)."
-          raise Rfm::CommunicationError.new(msg)
-        else
-          msg = "Unexpected response from server: #{response.code} (#{response.class.to_s}). Unable to communicate with the Web Publishing Engine."
-          raise Rfm::CommunicationError.new(msg)
-        end
-      end
-    
-      def expand_options(options)
-        result = {}
-        field_mapping = options.delete(:field_mapping) || {}
-        #puts field_mapping.to_yaml
-        options.each do |key,value|
-          case key.to_sym
-          when :max_portal_rows
-          	result['-relatedsets.max'] = value
-          	result['-relatedsets.filter'] = 'layout'
-          when :max_records
-            result['-max'] = value
-          when :skip_records
-            result['-skip'] = value
-          when :sort_field
-            if value.kind_of? Array
-              raise Rfm::ParameterError.new(":sort_field can have at most 9 fields, but you passed an array with #{value.size} elements.") if value.size > 9
-              value.each_index { |i| result["-sortfield.#{i+1}"] = field_mapping[value[i]] || value[i] }
-            else
-              result["-sortfield.1"] = field_mapping[value] || value
-            end
-          when :sort_order
-            if value.kind_of? Array
-              raise Rfm::ParameterError.new(":sort_order can have at most 9 fields, but you passed an array with #{value.size} elements.") if value.size > 9
-              value.each_index { |i| result["-sortorder.#{i+1}"] = value[i] }
-            else
-              result["-sortorder.1"] = value
-            end
-          when :post_script
-            if value.class == Array
-              result['-script'] = value[0]
-              result['-script.param'] = value[1]
-            else
-              result['-script'] = value
-            end
-          when :pre_find_script
-            if value.class == Array
-              result['-script.prefind'] = value[0]
-              result['-script.prefind.param'] = value[1]
-            else
-              result['-script.presort'] = value
-            end
-          when :pre_sort_script
-            if value.class == Array
-              result['-script.presort'] = value[0]
-              result['-script.presort.param'] = value[1]
-            else
-              result['-script.presort'] = value
-            end
-          when :response_layout
-            result['-lay.response'] = value
-          when :logical_operator
-            result['-lop'] = value
-          when :modification_id
-            result['-modid'] = value
-          else
-            raise Rfm::ParameterError.new("Invalid option: #{key}")
-          end
-        end
-        return result
-      end
     
   end
 end

data/lib/rfm/utilities/config.rb

@@ -1,7 +1,14 @@
 module Rfm
-
-  	# Should these go in Rfm module?
-  	CONFIG_KEYS = %w(
+	#
+	# 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'
+  	
+		CONFIG_KEYS = %w(
 			file_name
 			file_path
 			parser
@@ -26,17 +33,11 @@ module Rfm
 			parent
 			grammar
 			field_mapping
+			capture_strings_with
+			logger
 		)
 		
-		CONFIG_DONT_STORE = %w(strings using parents symbols objects)
-
-	# 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'
+		CONFIG_DONT_STORE = %w(strings using parents symbols objects)  #capture_strings_with)
   	
     extend self
     @config = {}
@@ -57,17 +58,17 @@ module Rfm
 	  #    Factory.layout 'my_layout', :my_group  # to get a layout from settings in :my_group
 	  #
 	  def config(*args, &block)
-	  	opt = args.rfm_extract_options!
 	  	@config ||= {}
-			config_write(opt, args, &block)
+	  	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)
-	  	opt = args.rfm_extract_options!
 	  	@config = {}
-			config_write(opt, args)
+	  	return @config if args.empty?
+			config_write(*args)
 			@config
 	  end
 	  
@@ -84,21 +85,15 @@ module Rfm
 		#    get_config :layout => 'my_layout
 		#
   	def get_config(*arguments)
+  		#puts caller_locations(1,1)[0]
   		args = arguments.clone
   		@config ||= {}
-  		opt = args.rfm_extract_options!
-  		strings = opt[:strings].rfm_force_array || []
-  		symbols = opt[:use].rfm_force_array || []
-  		objects = opt[:objects].rfm_force_array || []
-  		args.each do |arg|
-  			case true
-  			when arg.is_a?(String) ; strings << arg
-  			when arg.is_a?(Symbol) ; symbols << arg
-  			else objects.unshift arg
-  			end
-  		end
+  		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(opt)
+			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 ""
@@ -106,12 +101,16 @@ module Rfm
 			rslt.merge(:strings=>strings, :objects=>objects)
   	end
   	
-  	# 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
+		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
 	
@@ -130,38 +129,66 @@ module Rfm
 				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 strings in args. See base.rb.
-	  def config_write(opt, args)
-	  	strings = []; while args[0].is_a?(String) do; strings << args.shift; end
-	  	args.each{|a| @config.merge!(:use=>a.to_sym)}
-	  	@config.merge!(opt).reject! {|k,v| CONFIG_DONT_STORE.include? k.to_s}
-	  	yield(strings) if block_given?
+		# 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)
-      remote = if (self != Rfm::Config) 
-      	eval(@config[:parent] || 'Rfm::Config').config_merge_with_parent rescue {}
+	  	@config ||= {}
+	  	
+	  	# Get upstream compilation
+      upstream = if (self != Rfm::Config)
+      	#puts [self, @config[:parent], get_config_parent].join(', ')
+      	get_config_parent.config_merge_with_parent
       else
-      	get_config_file.merge((defined?(RFM_CONFIG) and RFM_CONFIG.is_a?(Hash)) ? RFM_CONFIG : {})
+      	get_config_base
       end.clone
-      
-      remote[:using] ||= []
-      remote[:parents] ||= ['file', 'RFM_CONFIG']
+            
+      upstream[:using] ||= []
+      upstream[:parents] ||= ['file', 'RFM_CONFIG']
 
 			filters = (@config[:use].rfm_force_array | filters.rfm_force_array).compact
-			rslt = config_filter(remote, 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.delete :parent
 			
-			rslt
+			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
@@ -169,15 +196,33 @@ module Rfm
 		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.blank?
+			filters.each{|f| next unless conf[f]; conf.merge!(conf[f] || {})} if (!filters.nil? && !filters.empty?)
 			conf.delete(:use)
 			conf
 		end
 		
-		    
-    # This loads RFM_CONFIG into @config. It is not necessary,
-    # as get_config will merge all configuration into RFM_CONFIG at runtime.
-    #config RFM_CONFIG if defined? RFM_CONFIG
+		# 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