ginjo-rfm 2.0.2 → 2.1.0.pre02

data/lib/rfm/server.rb

@@ -107,6 +107,9 @@ 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
+    
   
     # To create a Server object, you typically need at least a host name:
     # 
@@ -192,10 +195,14 @@ module Rfm
     #            :root_cert_name => 'example.pem'
     #            :root_cert_path => '/usr/cert_file/'
     #            })
-    def initialize(options)
-    	raise Rfm::Error::RfmError.new(0, "New instance of Rfm::Server has no host name. Attempted name '#{options[:host]}'.") if options[:host].to_s == ''
+    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 == ''
       
-      @state = {
+      @defaults = {
         :host => 'localhost',
         :port => 80,
         :ssl => true,
@@ -210,18 +217,13 @@ module Rfm
         :warn_on_redirect => true,
         :raise_on_401 => false,
         :timeout => 60,
-        :ignore_bad_data => false
-      }.merge(options)
-    
-      @state.freeze
-          
-      @host_name = @state[:host]
-      @scheme = @state[:ssl] ? "https" : "http"
-      @port = @state[:ssl] && options[:port].nil? ? 443 : @state[:port]
+        :ignore_bad_data => false,
+        :grammar => 'fmresultset'
+      }   #.merge(options)
       
-      @db = Rfm::Factory::DbFactory.new(self)
+      @databases = Rfm::Factory::DbFactory.new(self)
     end
-    
+   	
     # Access the database object representing a database on the server. For example:
     #
     #   myServer['Customers']
@@ -237,10 +239,19 @@ module Rfm
 		#     def [](dbname, acnt=nil, pass=nil)
 		#       self.db[dbname, acnt, pass]
 		#     end
-    def_delegator :db, :[]
+    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
     
-    attr_reader :db, :host_name, :port, :scheme, :state
-    alias_method :databases, :db
+    def state(*args)
+    	@defaults.merge(get_config(*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
     
     # 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."
@@ -270,16 +281,27 @@ 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 => ''})
-      http_fetch(@host_name, @port, "/fmi/xml/fmresultset.xml", account_name, password, post)
+      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)
+      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=\"[^\"]*\"/, '')
@@ -290,11 +312,11 @@ module Rfm
       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
+        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}"
+          warn "#{scheme}://#{host_name}:#{port}#{path}?#{qs_unescaped}"
         end
     
         request = Net::HTTP::Post.new(path)
@@ -303,19 +325,19 @@ module Rfm
     
         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.open_timeout = response.read_timeout = state[:timeout]
+        if state[:ssl]
           response.use_ssl = true
-          if @state[:root_cert]
+          if state[:root_cert]
             response.verify_mode = OpenSSL::SSL::VERIFY_PEER
-            response.ca_file = File.join(@state[:root_cert_path], @state[:root_cert_name])
+            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
+        if state[:log_responses] == true
           response.to_hash.each { |key, value| warn "#{key}: #{value}" }
           warn response.body
         end
@@ -324,7 +346,7 @@ module Rfm
         when Net::HTTPSuccess
           response
         when Net::HTTPRedirection
-          if @state[:warn_on_redirect]
+          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

data/lib/rfm/utilities/config.rb

@@ -1,13 +1,6 @@
 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.
-	#
-  module Config
-  	require 'yaml'
-  	
+  	# Should these go in Rfm module?
   	CONFIG_KEYS = %w(
 			file_name
 			file_path
@@ -31,10 +24,21 @@ module Rfm
 			log_parser
 			use
 			parent
+			grammar
 		)
+		
+		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'
+  	
     extend self
-    @config = {}		
+    @config = {}
 	  	  
 	  # Set @config with args & options hash.
 	  # Args should be symbols representing configuration groups,
@@ -78,16 +82,34 @@ module Rfm
 		# == Gets top level settings, merged with local and ad-hoc settings.
 		#    get_config :layout => 'my_layout
 		#
-  	def get_config(*args)
+  	def get_config(*arguments)
+  		args = arguments.clone
   		@config ||= {}
   		opt = args.rfm_extract_options!
-  		strings = []
-  		while args[0].is_a?(String) do; strings << args.shift; end
-	    if args.size == 0
-	    	config_filter(config_merge_with_parent)
-	    else
-	    	config_filter(config_merge_with_parent, args)
-	    end.merge(opt).merge(:strings=>strings)
+  		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
+
+			rslt = config_merge_with_parent(symbols).merge(opt)
+			#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
+  	
+  	# 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
   		  
 	protected
@@ -115,37 +137,39 @@ module Rfm
 	  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)
+	  	@config.merge!(opt).reject! {|k,v| CONFIG_DONT_STORE.include? k.to_s}
 	  	yield(strings) if block_given?
 	  end
 	  	
-	  # Get composite config from all levels, adding :use parameters to a
-	  # temporary top-level value.
-	  def config_merge_with_parent
+	  # 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 {}
       else
       	get_config_file.merge((defined?(RFM_CONFIG) and RFM_CONFIG.is_a?(Hash)) ? RFM_CONFIG : {})
-      end
+      end.clone
       
-      use = (remote[:use].rfm_force_array | @config[:use].rfm_force_array).compact
-			remote.merge(@config).merge(:use=>use)
+      remote[:using] ||= []
+      remote[: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[:using].concat((@config[:use].rfm_force_array | filters).compact.flatten)   #.join
+			rslt[:parents] << @config[:parent].to_s
+			
+			rslt.delete :parent
+			
+			rslt
     end
      
-		# This version uses either/or method input filters OR compiled config :use=>filters.
-		# Given config hash, return filtered subgroup settings. Filters should be symbols.
-		# 		def config_filter(conf, filters=nil)
-		# 			filters ||= conf[:use].rfm_force_array if !conf[:use].blank?
-		# 			filters.each{|f| next unless conf[f]; conf.merge!(conf[f] || {})} if !filters.blank?
-		# 			conf.reject!{|k,v| !CONFIG_KEYS.include?(k.to_s) or v.to_s == '' }
-		# 			conf
-		# 		end
-		#
-		# This version combines both method input filters AND :use=>filters
+		# 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)
-			filters = conf[:use] = (conf[:use].rfm_force_array | filters.rfm_force_array).compact
+			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?
-			conf.reject!{|k,v| !CONFIG_KEYS.include?(k.to_s) or [{},[],''].include?(v) }
+			conf.delete(:use)
 			conf
 		end
 		

data/lib/rfm/utilities/core_ext.rb

@@ -32,11 +32,12 @@ class Object
 	# since XmlMini doesn't know which will be returnd for any particular element.
 	# See Rfm Layout & Record where this is used.
 	def rfm_force_array
+		return [] if self.nil?
 		self.is_a?(Array) ? self : [self]
 	end
 	
 	# Just testing this functionality
-	def local_methods
+	def rfm_local_methods
 		self.methods - self.class.superclass.methods
 	end
   
@@ -62,8 +63,73 @@ class Array
 	def rfm_extract_options!
 	  last.is_a?(::Hash) ? pop : {}
 	end
+
+	# These methods allow dynamic extension of array members with other modules.
+	# These methods also carry the @root object for reference, when you don't have the
+	# root object explicity referenced anywhere.
+	#
+	# These methods might slow down array traversal, as
+	# they add interpreted code to methods that were otherwise pure C.	
+  def rfm_extend_members(klass, caller=nil)
+  	@parent = caller
+    @root = caller.instance_variable_get(:@root)
+  	@member_extension = klass
+  	self.instance_eval do
+  	  class << self
+  	  	attr_accessor :parent
+	
+    		alias_method 'old_reader', '[]'
+    		def [](*args)
+    			member = old_reader(*args)
+          rfm_extend_member(member, @member_extension, args[0]) if args[0].is_a? Integer
+    			member
+    		end
+		
+    		alias_method 'old_each', 'each'
+    		def each
+    			i = -1
+    			old_each do |member|
+    				i = i + 1
+    				rfm_extend_member(member, @member_extension, i)
+    				yield(member)
+    			end
+    		end
+  	  end
+  	end unless defined? old_reader
+  	self
+  end
+  
+  def rfm_extend_member(member, extension, i=nil)
+  	if member and extension
+	    unless member.instance_variable_get(:@root)
+			  member.instance_variable_set(:@root, @root)
+			  member.instance_variable_set(:@parent, self)
+			  member.instance_variable_set(:@index, i)
+	  		member.instance_eval(){def root; @root; end}
+	  		member.instance_eval(){def parent; @parent; end}
+	  		member.instance_eval(){def get_index; @index; end}
+	  	end
+			member.extend(extension)
+		end  
+  end
+
 end # Array
 
+class Hash
+	# TODO: Possibly deprecated, delete if not used.
+	def rfm_only(*keepers)
+		self.each_key {|k| self.delete(k) if !keepers.include?(k)}
+	end
+	
+	def rfm_filter(*args)
+		options = args.rfm_extract_options!
+		delete = options[:delete]
+		self.each_key do |k|
+			self.delete(k) if (delete ? args.include?(k) : !args.include?(k))
+		end
+	end
+end # Hash
+
 # Allows access to superclass object
 class SuperProxy
   def initialize(obj)

data/lib/rfm/utilities/factory.rb

@@ -14,9 +14,14 @@ module Rfm
   
   	class ServerFactory < Rfm::CaseInsensitiveHash
       
-      def [](host, conf = Factory.get_config) #(Factory.instance_variable_get(:@config) || {}))
-      	conf[:host] = host
-        super(host) or (self[host] = Rfm::Server.new(conf.reject{|k,v| [:account_name, :password].include? k}))
+      def [](*args)
+      	options = Factory.get_config(*args)
+      	host = options[:strings].delete_at(0) || options[:host]
+        super(host) or (self[host] = Rfm::Server.new(host, options.rfm_filter(:account_name, :password, :delete=>true)))
+        # This part reconfigures the named server, if you pass it new config in the [] method.
+        # This breaks some specs in all [] methods in Factory. Consider undoing this. See readme-dev.
+				#   super(host).config(options) if (options)
+				#   super(host)
       end
 			
 			# Potential refactor
@@ -38,18 +43,22 @@ module Rfm
         @loaded = false
       end
       
-      def [](dbname, acnt=nil, pass=nil) #
-        db = (super(dbname) or (self[dbname] = Rfm::Database.new(dbname, @server)))
-        account_name = acnt || db.account_name || @server.state[:account_name]
-        password = pass || db.password || @server.state[:password]
-        db.account_name = account_name if account_name
-        db.password = password if password
-        db
+      def [](*args)
+      	# was: (dbname, acnt=nil, pass=nil)
+      	options = Factory.get_config(*args)
+      	name = options[:strings].delete_at(0) || options[:database]
+      	account_name = options[:strings].delete_at(0) || options[:account_name]
+      	password = options[:strings].delete_at(0) || options[:password]
+        super(name) or (self[name] = Rfm::Database.new(name, account_name, password, @server))
+        # This part reconfigures the named database, if you pass it new config in the [] method.
+				#   super(name).config({:account_name=>account_name, :password=>password}.merge(options)) if (account_name or password or options)
+				#   super(name)
       end
       
       def all
         if !@loaded
-          Rfm::Resultset.new(@server, @server.connect(@server.state[:account_name], @server.state[:password], '-dbnames', {}).body, nil).each {|record|
+        	xml = @server.connect(@server.state[:account_name], @server.state[:password], '-dbnames', {}).body
+          Rfm::Resultset.new(xml, :server_object => @server).each {|record|
             name = record['DATABASE_NAME']
             self[name] = Rfm::Database.new(name, @server) if self.keys.find{|k| k.to_s.downcase == name.to_s.downcase} == nil
           }
@@ -74,8 +83,13 @@ module Rfm
         @loaded = false
       end
       
-      def [](layout_name)
-        super or (self[layout_name] = Rfm::Layout.new(layout_name, @database))
+      def [](*args) # was layout_name
+      	options = Factory.get_config(*args)
+      	name = options[:strings].delete_at(0) || options[:layout]
+        super(name) or (self[name] = Rfm::Layout.new(name, @database, options))
+        # This part reconfigures the named layout, if you pass it new config in the [] method.
+				#   super(name).config({:layout=>name}.merge(options)) if options
+				#   super(name)
       end
       
       def all
@@ -98,7 +112,8 @@ module Rfm
       end
       
       def get_layout_names
-      	Rfm::Resultset.new(@server, get_layout_names_xml.body, nil)
+      	#Rfm::Resultset.new(@server, get_layout_names_xml.body, nil)
+      	Rfm::Resultset.new(get_layout_names_xml.body, :database_object => @database)
       end
     
     	def names
@@ -122,7 +137,8 @@ module Rfm
       
       def all
         if !@loaded
-          Rfm::Resultset.new(@server, @server.connect(@database.account_name, @database.password, '-scriptnames', {"-db" => @database.name}).body, nil).each {|record|
+        	xml = @server.connect(@database.account_name, @database.password, '-scriptnames', {"-db" => @database.name}).body
+          Rfm::Resultset.new(xml, :database_object => @database).each {|record|
             name = record['SCRIPT_NAME']
             self[name] = Rfm::Metadata::Script.new(name, @database) if self[name] == nil
           }
@@ -148,21 +164,22 @@ module Rfm
 	  	# Returns Rfm::Server instance, given config hash or array
 	  	def server(*conf)
 	  		options = get_config(*conf)
-	  		server_name = options[:strings][0] || options[:host]
-	  		raise Rfm::Error::RfmError.new(0, 'A host name is needed to create a server object.') if server_name.blank?
-				server = servers[server_name, options]
+				#server = servers[server_name, options]
+				# These disconnect servers from the ServerFactory hash, but it breaks the ActiveModel spec suite.
+				#Rfm::Server.new(server_name, options.rfm_filter(:account_name, :password, :delete=>true))
+				Rfm::Server.new(options)
 		  end
 			# Potential refactor
 			#def_delegator 'Rfm::Factory::ServerFactory', :[], :server  #, :[]
 	  
 		  # Returns Rfm::Db instance, given config hash or array
 		  def db(*conf)
-	  		options = get_config(*conf)
-	  		db_name = options[:strings][0] || options[:database]
-	  		raise Rfm::Error::RfmError.new(0, 'A database name is needed to create a database object.') if db_name.blank?
-	  		account_name = options[:strings][1] || options[:account_name]
-	  		password = options[:strings][2] || options[:password]
-				db = server(options)[db_name, account_name, password]
+		  	options = get_config(*conf)
+		  	name = options[:strings].delete_at(0) || options[:database]
+		  	account_name = options[:strings].delete_at(0) || options[:account_name]
+		  	password = options[:strings].delete_at(0) || options[:password]
+				s = server(options)
+				s[name, account_name, password, options]
 		  end
 		  
 		  alias_method :database, :db
@@ -170,9 +187,9 @@ module Rfm
 		  # Returns Rfm::Layout instance, given config hash or array
 	  	def layout(*conf)
 	  		options = get_config(*conf)
-	  		layout_name = options[:strings][0] || options[:layout]
-	  		raise Rfm::Error::RfmError.new(0, 'A layout name is needed to create a layout object.') if layout_name.blank?
-				layout = db(options)[layout_name]
+	  		name = options[:strings].delete_at(0) || options[:layout]
+				d = db(options)
+				d[name, options]
 	  	end
 
     end # class << self