ginjo-rfm 1.4.4 → 2.0.pre31

data/lib/rfm/utilities/config.rb

@@ -0,0 +1,115 @@
+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.
+	#
+	# All filters are honored, unless filters are included in calls to get_config,
+	# in which case only the immediately specified filters will be used.
+	#
+	# Do not put a :use=>:group filter in a subset (maybe future feature?).
+	# Do not put a :use=>:group filter in the top-level global parameters.
+	# Do not put subsets in non-top-level configs. (maybe future feature?)
+	#
+  module Config
+  	CONFIG_KEYS = %w(parser host port account_name password database layout ssl root_cert root_cert_name root_cert_path warn_on_redirect raise_on_401 timeout log_actions log_responses log_parser use parent)
+
+    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)
+	  	opt = args.rfm_extract_options!
+	  	@config ||= {}
+			config_write(opt, 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)
+			@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(*args)
+  		@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)
+  	end
+  		  
+	protected
+	  
+	  
+		# 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)
+	  	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
+      remote = if (self != Rfm::Config) 
+      	eval(@config[:parent] || 'Rfm::Config').config_merge_with_parent rescue {}
+      else
+      	(defined?(RFM_CONFIG) and RFM_CONFIG.is_a?(Hash)) ? RFM_CONFIG : {}
+      end
+      
+      use = (remote[:use].rfm_force_array | @config[:use].rfm_force_array).compact
+			remote.merge(@config).merge(:use=>use)
+    end	  
+
+		# Given config hash, return filtered. 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 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
+
+	end # module Config
+	
+end # module Rfm

data/lib/rfm/utilities/core_ext.rb

@@ -0,0 +1,90 @@
+require 'forwardable'
+
+Module.module_eval do
+	# Adds ability to forward methods to other objects using 'def_delegator'
+	include Forwardable
+end
+
+class Object # @private :nodoc: all
+
+	#extend Forwardable
+
+	# Adds methods to put instance variables in rfm_metaclass, plus getter/setters
+	# This is useful to hide instance variables in objects that would otherwise show "too much" information.
+  def self.meta_attr_accessor(*names)
+		meta_attr_reader(*names)
+		meta_attr_writer(*names)
+  end
+  
+  def self.meta_attr_reader(*names)
+    names.each do |n|
+      define_method(n.to_s) {rfm_metaclass.instance_variable_get("@#{n}")}
+    end
+  end
+  
+  def self.meta_attr_writer(*names)
+    names.each do |n|
+      define_method(n.to_s + "=") {|val| rfm_metaclass.instance_variable_set("@#{n}", val)}
+    end
+  end
+  
+  # Wrap an object in Array, if not already an Array,
+	# 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
+		self.is_a?(Array) ? self : [self]
+	end
+	
+	# Just testing this functionality
+	def local_methods
+		self.methods - self.class.superclass.methods
+	end
+  
+private
+
+	# Like singleton_method or 'metaclass' from ActiveSupport.
+	def rfm_metaclass
+		class << self
+			self
+		end
+	end
+  
+  # Get the superclass object of self.
+  def rfm_super
+    SuperProxy.new(self)
+  end
+  
+end # Object
+
+
+class Array
+	# Taken from ActiveSupport extract_options!.
+	def rfm_extract_options!
+	  last.is_a?(::Hash) ? pop : {}
+	end
+end # Array
+
+# Allows access to superclass object
+class SuperProxy
+  def initialize(obj)
+    @obj = obj
+  end
+
+  def method_missing(meth, *args, &blk)
+    @obj.class.superclass.instance_method(meth).bind(@obj).call(*args, &blk)
+  end
+end # SuperProxy
+
+
+class Time
+	# Returns array of [date,time] in format suitable for FMP.
+	def to_fm_components(reset_time_if_before_today=false)
+		d = self.strftime('%m/%d/%Y')
+		t = if (Date.parse(self.to_s) < Date.today) and reset_time_if_before_today==true
+			"00:00:00"
+		else
+			self.strftime('%T')
+		end
+		[d,t]
+	end
+end # Time

data/lib/rfm/utilities/factory.rb

@@ -7,32 +7,64 @@
 
 
 module Rfm
-  module Factory # :nodoc: all
-    class DbFactory < Rfm::CaseInsensitiveHash
+
+  module Factory 
+  	extend Config
+  	config :parent=>'Rfm::Config'
+  
+  	class ServerFactory < Rfm::CaseInsensitiveHash # @private :nodoc: all
+      
+      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}))
+      end
+			
+			# Potential refactor
+			# 		def [](*conf)
+			# 			options = Factory.get_config(*conf)
+			#   		server_name = options[:strings][0] || options[:host]
+			#   		options[:host] = server_name
+			# 			#server = servers[server_name, options]
+			# 			super(server_name) or (self[server_name] = Rfm::Server.new(options.reject{|k,v| [:account_name, :password].include? k}))
+			# 		end
+    
+    end # ServerFactory
+    
+    
+    class DbFactory < Rfm::CaseInsensitiveHash # :nodoc: all
     
       def initialize(server)
         @server = server
         @loaded = false
       end
       
-      def [](dbname)
-        super or (self[dbname] = Rfm::Database.new(dbname, @server))
+      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
       end
       
       def all
         if !@loaded
           Rfm::Resultset.new(@server, @server.connect(@server.state[:account_name], @server.state[:password], '-dbnames', {}).body, nil).each {|record|
             name = record['DATABASE_NAME']
-            self[name] = Rfm::Database.new(name, @server) if self[name] == nil
+            self[name] = Rfm::Database.new(name, @server) if self.keys.find{|k| k.to_s.downcase == name.to_s.downcase} == nil
           }
           @loaded = true
         end
-        self.keys
+        self
+      end
+      
+      def names
+      	keys
       end
     
-    end
+    end # DbFactory
     
-    class LayoutFactory < Rfm::CaseInsensitiveHash
+    class LayoutFactory < Rfm::CaseInsensitiveHash # :nodoc: all
     
       def initialize(server, database)
         @server = server
@@ -46,18 +78,24 @@ module Rfm
       
       def all
         if !@loaded
-	        Rfm::Resultset.new(@server, @server.connect(@server.state[:account_name], @server.state[:password], '-layoutnames', {"-db" => @database.name}).body, nil).each {|record|
+	        Rfm::Resultset.new(@server, @server.connect(@database.account_name, @database.password, '-layoutnames', {"-db" => @database.name}).body, nil).each {|record|
 	          name = record['LAYOUT_NAME']
 	          self[name] = Rfm::Layout.new(name, @database) if self[name] == nil
 	        }
           @loaded = true
         end
-        self.keys
+        self
       end
     
-    end
+    	def names
+    		keys
+    	end
+    	
+
+    
+    end # LayoutFactory
     
-    class ScriptFactory < Rfm::CaseInsensitiveHash
+    class ScriptFactory < Rfm::CaseInsensitiveHash # :nodoc: all
     
       def initialize(server, database)
         @server = server
@@ -71,15 +109,60 @@ module Rfm
       
       def all
         if !@loaded
-          Rfm::Resultset.new(@server, @server.connect(@server.state[:account_name], @server.state[:password], '-scriptnames', {"-db" => @database.name}).body, nil).each {|record|
+          Rfm::Resultset.new(@server, @server.connect(@database.account_name, @database.password, '-scriptnames', {"-db" => @database.name}).body, nil).each {|record|
             name = record['SCRIPT_NAME']
             self[name] = Rfm::Metadata::Script.new(name, @database) if self[name] == nil
           }
           @loaded = true
         end
-        self.keys
+        self
       end
+ 
+ 			def names
+ 				keys
+ 			end
+    
+    end # ScriptFactory
+    
+    
+    
+    class << self
+    	
+			def servers
+				@servers ||= ServerFactory.new
+			end    
+    
+	  	# 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]
+		  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]
+		  end
+		  
+		  alias_method :database, :db
+		  
+		  # 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]
+	  	end
+
+    end # class << self
     
-    end
-  end
-end
+  end # Factory
+end # Rfm

data/lib/rfm/utilities/xml_parser.rb

@@ -0,0 +1,94 @@
+module Rfm
+	module XmlParser # @private :nodoc: all
+
+		extend Config
+		config :parent=>'Rfm::Config'
+		
+		extend self
+		
+		# Backend configurations
+		BACKENDS = ActiveSupport::OrderedHash.new
+		
+		BACKENDS[:jdom]					= {:require=>'jdom',			:class =>	'JDOM'}
+		BACKENDS[:libxml]				= {:require=>'libxml',		:class =>	'LibXML'}
+		BACKENDS[:libxmlsax]		= {:require=>'libxml',		:class =>	'LibXMLSAX'}
+		BACKENDS[:nokogirisax]	= {:require=>'nokogiri',	:class =>	proc{ActiveSupport::VERSION; 'NokogiriSAX'}}
+		BACKENDS[:nokogiri]			= {:require=>'nokogiri',	:class =>	'Nokogiri'}
+		BACKENDS[:hpricot]			= {:require=>'hpricot',	  :class =>	proc{
+																# Hpricot module is part of Rfm, not XmlMini,
+																# and needs to be handed manually to XmlMini.
+																require File.join(File.dirname(__FILE__), '../xml_mini/hpricot.rb')
+																ActiveSupport::XmlMini_Hpricot}}
+		BACKENDS[:rexml]				= {:require=>'rexml/document',	:class=>'REXML'}
+		
+		
+		# Main parsing method.
+		# Options
+		#		:namespace => false   # strip out namespace (default)
+		#		:parser    => :libxml, :libxmlsax, :nokogirisax, :nokogiri, :hpricot, :rexml
+		#		:parser    => CustomParsingModule  # see ActiveSupport::XmlMini
+		def new(string_or_file, opts={})
+			string_or_file.gsub!(/xmlns=\"[^\"]*\"/,'') if (string_or_file.class == String and opts[:namespace] == false)
+			unless opts[:parser] and get_backend_from_hash(opts[:parser]).to_s != self.backend.to_s
+				warn "XmlParser default: #{ActiveSupport::XmlMini.backend.to_s}" if get_config[:log_parser] == true
+				ActiveSupport::XmlMini.parse(string_or_file)
+			else
+				warn "XmlParser backend: #{get_backend_from_hash(opts[:parser]).to_s}" if get_config[:log_parser] == true
+				ActiveSupport::XmlMini.with_backend(get_backend_from_hash(opts[:parser])) {ActiveSupport::XmlMini.parse(string_or_file)}
+			end
+		end
+				
+		# Shortcut to XmlMini config getter.
+		# If a parameter is passed, it will be used to get the local backend description
+		# from the BACKENDS hash, instead of the XmlMini backend.
+		def backend(name=nil)
+			return ActiveSupport::XmlMini.backend unless name
+			get_backend_from_hash(name)
+		end
+		
+		# Shortcut to XmlMini config setter.
+		def backend=(name)
+			if name.is_a? Symbol
+				set_backend_via_hash(name)
+			else
+				ActiveSupport::XmlMini.backend = name
+			end
+		end
+		
+	private
+		
+		# Given name, return backend config from BACKENDS, including any preloading.
+		# Will raise LoadError if can't load backend.
+		def get_backend_from_hash(name)
+				backend_hash = BACKENDS[name.to_sym]
+				require backend_hash[:require]
+				backend_hash[:class].is_a?(Proc) ? backend_hash[:class].call : backend_hash[:class]
+		end
+		
+		# Set XmlMini backend, given symbol matching one of the BACKENDS.
+		def set_backend_via_hash(name)
+			ActiveSupport::XmlMini.backend = get_backend_from_hash(name)
+		end
+		
+		# Select the best backend from BACKENDS, returns backend config.
+		def decide_backend
+			string_or_class = catch(:done) do
+				BACKENDS.keys.each do |name|
+					begin
+						result = get_backend_from_hash name
+						throw(:done, result)
+					rescue LoadError, StandardError
+					end
+				end
+			end
+		end
+				
+		# Set XmlMini backend when this file loads.
+		begin
+			self.backend = get_backend_from_hash(get_config[:parser])
+		rescue
+			self.backend = decide_backend
+		end
+		
+	end # XmlParser
+end # Rfm