ginjo-rfm 2.1.7 → 3.0.0

data/lib/rfm.rb

@@ -3,16 +3,11 @@ module Rfm
 	$LOAD_PATH.unshift(PATH) unless $LOAD_PATH.include?(PATH)
 end
 
-require 'thread' # some versions of ActiveSupport will raise error about Mutex unless 'thread' is loaded.
-require 'active_support'
-require 'active_support/core_ext/object/blank'
-require 'active_support/ordered_hash'
-require 'active_support/version'
+#require 'thread' # some versions of ActiveSupport will raise error about Mutex unless 'thread' is loaded.
+
+require 'logger'
 require 'rfm/utilities/core_ext'
 require 'rfm/utilities/case_insensitive_hash'
-#require 'rfm/utilities/config'
-#require 'rfm/utilities/factory'
-#require 'rfm/version.rb'
 
 module Rfm
   
@@ -27,45 +22,49 @@ module Rfm
   autoload :Resultset,    'rfm/resultset'
   autoload :Record,       'rfm/record'
   autoload :Base,         'rfm/base'
-  autoload :XmlParser,    'rfm/utilities/xml_parser'
+  autoload :SaxParser,    'rfm/utilities/sax_parser'
   autoload :Config,       'rfm/utilities/config'
   autoload :Factory,      'rfm/utilities/factory'
   autoload :CompoundQuery,'rfm/utilities/compound_query'
   autoload :VERSION,      'rfm/version'
-  autoload :Fmresultset,	'rfm/utilities/fmresultset.rb'
-  autoload :Fmpxmlresult,	'rfm/utilities/fmpxmlresult.rb'
-  autoload :Fmpdsoresult,	'rfm/utilities/fmpdsoresult.rb'
-  autoload :Fmpxmllayout,	'rfm/utilities/fmpxmllayout.rb'
+  autoload :Connection,   'rfm/utilities/connection.rb'
 
 	module Metadata
 		autoload :Script,         'rfm/metadata/script'
 		autoload :Field,          'rfm/metadata/field'
 		autoload :FieldControl,   'rfm/metadata/field_control'
 		autoload :ValueListItem,  'rfm/metadata/value_list_item'
+		autoload :Datum,  				'rfm/metadata/datum'
+		autoload :ResultsetMeta,  'rfm/metadata/resultset_meta'
+		autoload :LayoutMeta,     'rfm/metadata/layout_meta'
 	end
 
 	def info
     rslt = <<-EEOOFF
-      Name: ginjo-rfm
+      Gem name: ginjo-rfm
       Version: #{VERSION}
-      ActiveSupport Version: #{ActiveSupport::VERSION::STRING}
-      ActiveModel Loaded? #{defined?(ActiveModel) ? 'true' : 'false'}
-      ActiveModel Loadable? #{begin; require 'active_model'; rescue LoadError; $!; end}
-      XML Parser: #{XmlParser.backend}
+      ActiveModel loadable? #{begin; Gem::Specification::find_all_by_name('activemodel')[0].version.to_s; rescue Exception; false; end}
+      ActiveModel loaded? #{defined?(ActiveModel) ? 'true' : 'false'}
+      XML default parser: #{SaxParser::Handler.get_backend}
+      Ruby: #{RUBY_VERSION}
     EEOOFF
     rslt.gsub!(/^[ \t]*/, '')
+    rslt
   rescue
   	"Could not retrieve info: #{$!}"
 	end
 	
 	def info_short
-		"Using ginjo-rfm version #{::Rfm::VERSION} with #{XmlParser.backend}"
+		"Using ginjo-rfm version #{::Rfm::VERSION} with #{SaxParser::Handler.get_backend}"
 	end
 	
 	def_delegators 'Rfm::Factory', :servers, :server, :db, :database, :layout
-	def_delegators 'Rfm::XmlParser', :backend, :backend=
+	def_delegators 'Rfm::SaxParser', :backend, :backend=
+	def_delegators 'Rfm::SaxParser::Handler', :get_backend
 	def_delegators 'Rfm::Config', :config, :get_config, :config_clear
 	def_delegators 'Rfm::Resultset', :load_data
+	alias_method		:parser, :backend
+	alias_method		:parser=, :backend=
 	
 	def models(*args)
 		Rfm::Base
@@ -77,6 +76,29 @@ module Rfm
 		Rfm::Factory.modelize(*args)
 	end
 	
+	#attr_accessor :log
+	
+	def logger
+		@@logger ||= get_config[:logger] || Logger.new(STDOUT).tap {|l| l.formatter = proc {|severity, datetime, progname, msg| "#{datetime}: Rfm-#{severity} #{msg}\n"}}
+	end
+	
+	alias_method :log, :logger
+	
+	def logger=(obj)
+		@@logger = obj
+	end
+	
+	
+	
 	extend self
+	
+	SaxParser.default_class = CaseInsensitiveHash
+	SaxParser.template_prefix = File.join(File.dirname(__FILE__), 'rfm/utilities/sax/')
+	SaxParser.templates.merge!({
+		:fmpxmllayout => 'fmpxmllayout.yml',
+		:fmresultset => 'fmresultset.yml',
+		:fmpxmlresult => 'fmpxmlresult.yml',
+		:none => nil
+	})
 
 end # Rfm

data/lib/rfm/VERSION

@@ -1 +1 @@
-2.1.7
+3.0.0

data/lib/rfm/base.rb

@@ -30,137 +30,7 @@ module Rfm
 	#   @person = Person.find({:name => 'mike'}, :max_records => 50)[0]
 	#   @person.update_attributes(:name => 'Michael', :title => "Senior Partner")
 	#   @person.save
-	# 
 	#
-	require 'active_support/core_ext/string/inflections'
-	require 'rfm/database'
-	require 'rfm/layout'
-	require 'rfm/record'
-	require 'rfm/utilities/factory'
-	require 'delegate' 
-  
-  class Layout
-
-  	class SubLayout < DelegateClass(Layout)
-  		# Added by wbr to give config heirarchy: layout -> model -> sublayout
-			include Config  	
-  	
-  		include Layout::LayoutModule
-   		attr_accessor :model, :parent_layout
-
-  		def initialize(master)
-  			super(master)
-  			self.parent_layout = master
-  		end
-  	end # SubLayout
-  	
-    attr_accessor :subs
-  	
-  	alias_method :main_init, :initialize
-		def initialize(*args)
-	    @subs ||= []
-	    main_init(*args)
-	  end
-    
-    def sublayout
-    	if self.is_a?(Rfm::Layout)
-    		sub = SubLayout.new(self); subs << sub; sub
-    	else
-    		self
-    	end
-    end
-  	
-    # Creates new class with layout name, subclassed from Rfm::Base, and links the new model to a SubLayout instance.
-    def modelize
-    	model_name = name.to_s.gsub(/\W/, '_').classify.gsub(/_/,'')
-    	(return model_name.constantize) rescue nil
-    	sub = sublayout
-    	sub.instance_eval do
-	    	model_class = eval("::" + model_name + "= Class.new(Rfm::Base)")
-	    	model_class.class_exec(self) do |layout_obj|
-	    		@layout = layout_obj
-	    	end
-	    	@model = model_class
-	    	
-	  		# Added by wbr to give config heirarchy: layout -> model -> sublayout
-	  		model.config :parent=>'@layout.parent_layout'
-	    	config :parent=>'model'
-	    end
-	    sub.model.to_s.constantize
-    rescue StandardError, SyntaxError
-    	nil
-  	end
-  	
-  	def models
-  		subs.collect{|s| s.model}
-  	end
-
-  end # Layout
-  
-
-
-
-        
-  class Record
-  	class << self
-			def new(*args)
-				#puts "Creating new record from RECORD. Layout: #{args[3].class} #{args[3].object_id}"
-				args[3].model.new(*args)
-			rescue
-				#puts "RECORD failed to send 'new' to MODEL"
-				super
-				#allocate.send(:initialize, *args)
-			end
-    end # class << self
-  end # class Record
-
-
-
-
-  
-  class Database
-  	def_delegators :layouts, :modelize, :models
-  end
-
-
-
-  
-  module Factory
-    @models ||= []
-
-  	class << self
-  		attr_accessor :models
-  		
-	  	# Shortcut to Factory.db().layouts.modelize()
-	  	# If first parameter is regex, it is used for modelize filter.
-	  	# Otherwise, parameters are passed to Factory.database
-	  	def modelize(*args)
-	  		regx = args[0].is_a?(Regexp) ? args.shift : /.*/
-	  		db(*args).layouts.modelize(regx)
-	  	end
-  	end # class << self
-  	
-  	class LayoutFactory
-    	def modelize(filter = /.*/)
-    		all.values.each{|lay| lay.modelize if lay.name.match(filter)}
-    		models
-    	end
-    	
-    	def models
-	    	rslt = {}
-    		each do |k,lay|
-    			layout_models = lay.models
-    			rslt[k] = layout_models if !layout_models.blank?
-	    	end
-	    	rslt
-    	end
-    	
-    end # LayoutFactory
-  end # Factory
-	
-
-
-	
   class Base <  Rfm::Record  #Hash
     extend Config
     config :parent => 'Rfm::Config'
@@ -177,24 +47,6 @@ module Rfm
     		yield
     	end
     end
-    
-		def initialize(record={}, resultset_obj=[], field_meta='', layout_obj=self.class.layout, portal=nil)
-			if resultset_obj == [] and !record.respond_to?(:columns) #.has_key? 'field'
-				@mods = Rfm::CaseInsensitiveHash.new
-				@layout = layout_obj
-				@resultset = Resultset.allocate
-        # loop thru each layout field, creating hash keys with nil values
-        layout_obj.field_names.each do |field|
-          field_name = field.to_s
-          self[field_name] = nil
-        end
-        self.update_attributes(record) unless record == {}
-        self.merge!(@mods) unless @mods == {}
-        @loaded = true
-      else
-      	super
-      end
-		end
 		
     def to_partial_path(object = self) #@object)
     	return 'some/partial/path'
@@ -220,39 +72,34 @@ module Rfm
 				(Rfm::Factory.models << model).uniq unless Rfm::Factory.models.include? model
 				model.config :parent=>'Rfm::Base'
 			end
-		
-			# Build a new record without saving
-		  def new(*args)
-		  	# Without this method, infinite recursion will happen from Record.new
-		  	#puts "Creating new record from BASE"
-		    rec = self.allocate
-		    rec.send(:initialize, *args)
-		    rec
-		  end
 		  
 	    def config(*args)
-	    	super(*args){|strings| @config.merge!(:layout=>strings[0]) if strings[0]}
+	    	super(*args){|options| @config.merge!(:layout=>options[:strings][0]) if options[:strings] && options[:strings][0]}
 	    end
 		  		  			
 			# Access/create the layout object associated with this model
 	  	def layout
 	  		return @layout if @layout
-	  		cnf = get_config
-	  		raise "Could not get :layout from get_config in Base.layout method" unless cnf[:layout] #return unless cnf[:layout]
-	  		@layout = Rfm::Factory.layout(cnf).sublayout
+# 	  		cnf = get_config
+# 	  		raise "Could not get :layout from get_config in Base.layout method" unless cnf[:layout] #return unless cnf[:layout]
+# 	  		@layout = Rfm::Factory.layout(cnf).sublayout
+				name = get_config[:layout] || 'test'   # The 'test' was added to help active-model-lint tests pass.
+				@layout = Rfm::Factory.layout(name, self) #.sublayout
 	  		
 	  		# Added by wbr to give config heirarchy: layout -> model -> sublayout
-	  		config :parent=>'parent_layout'
-	  		@layout.config :parent=>'model'
+	  		#config :parent=>'parent_layout'
+	  		#config :parent=>'Rfm::Config'
+	  		#@layout.config model
+	  		#@layout.config :parent=>self
 	  		
 				@layout.model = self
 				@layout
 	  	end
 	  	
-	  	# Access the parent layout of this model
-	  	def parent_layout
-	  		layout.parent_layout
-	  	end
+# 	  	# Access the parent layout of this model
+# 	  	def parent_layout
+# 	  		layout #.parent_layout
+# 	  	end
 		  			
 			# Just like Layout#find, but searching by record_id will return a record, not a resultset.
 	  	def find(find_criteria, options={})
@@ -291,41 +138,57 @@ module Rfm
 		
 		# Is this a newly created record, not saved yet?					
   	def new_record?
-  		return true if self.record_id.blank?
+  		return true if (self.record_id.nil? || self.record_id.empty?)
   	end
 
 		# Reload record from database
 		# TODO: handle error when record has been deleted
+		# TODO: Move this to Rfm::Record.
 		def reload(force=false)
 	    if (@mods.empty? or force) and record_id
 	    	@mods.clear
-	      self.replace self.class.find(self.record_id)
+	      self.replace_with_fresh_data layout.find(self.record_id)[0]   #self.class.find(self.record_id)
       end
     end
     
     # Mass update of record attributes, without saving.
-    # TODO: return error or nil if input hash contains no recognizable keys.
     def update_attributes(new_attr)
-      # creates new special hash
-      input_hash = Rfm::CaseInsensitiveHash.new
-      # populate new hash with input, coercing keys to strings
-      new_attr.each{|k,v| input_hash.merge! k.to_s=>v}
-      # loop thru each layout field, adding data to @mods
-      self.class.field_controls.keys.each do |field| 
-        field_name = field.to_s
-        if input_hash.has_key?(field_name)
-          @mods.merge! field_name=>(input_hash[field_name] || '')
-        end
-      end
-      # loop thru each input key-value,
-      # creating new attribute if key doesn't exist in model.
-      input_hash.each do |k,v| 
-        if !self.class.field_controls.keys.include?(k) and self.respond_to?(k)
-          self.instance_variable_set("@#{k}", v)
-        end
-      end            
-      self.merge!(@mods) unless @mods == {}
+    	new_attr.each do |k,v|
+    		k = k.to_s.downcase
+    		if keys.include?(k)
+    			@mods[k] = v
+    			self[k] = v
+    		else
+    			instance_variable_set("@#{k}", v)
+    		end
+    	end
     end
+		#     # Mass update of record attributes, without saving.
+		#     # TODO: return error or nil if input hash contains no recognizable keys.
+		#     def update_attributes(new_attr)
+		#       # creates new special hash
+		#       input_hash = Rfm::CaseInsensitiveHash.new
+		#       # populate new hash with input, coercing keys to strings
+		#       #new_attr.each{|k,v| input_hash.merge! k.to_s=>v}
+		#       new_attr.each{|k,v| input_hash[k.to_s] = v}
+		#       # loop thru each layout field, adding data to @mods
+		#       self.class.field_controls.keys.each do |field| 
+		#         field_name = field.to_s
+		#         if input_hash.has_key?(field_name)
+		#           #@mods.merge! field_name=>(input_hash[field_name] || '')
+		#           @mods[field_name] = (input_hash[field_name] || '')
+		#         end
+		#       end
+		#       # loop thru each input key-value,
+		#       # creating new attribute if key doesn't exist in model.
+		#       input_hash.each do |k,v| 
+		#         if !self.class.field_controls.keys.include?(k) and self.respond_to?(k)
+		#           self.instance_variable_set("@#{k}", v)
+		#         end
+		#       end            
+		#       self.merge!(@mods) unless @mods == {}
+		#       #self.merge!(@mods) unless @mods == Rfm::CaseInsensitiveHash.new
+		#     end
     
     # Mass update of record attributes, with saving.
     def update_attributes!(new_attr)
@@ -335,7 +198,8 @@ module Rfm
     
     # Save record modifications to database (with callbacks & validations). If record cannot be saved will raise error.
     def save!
-      #raise "Record Invalid" unless valid? rescue nil
+      #return unless @mods.size > 0
+      raise "Record Invalid" unless valid? rescue nil
       if @record_id
         self.update
       else
@@ -347,7 +211,7 @@ module Rfm
     def save
       save!
     rescue
-      # (self.errors[:base] rescue []) << $!
+      (self.errors[:base] rescue []) << $!
       return nil
     end
 	  
@@ -405,7 +269,8 @@ module Rfm
       raise "Record not valid" if (defined?(ActiveModel::Validations) && !valid?)
       run_callbacks :create do
         return unless @mods.size > 0
-  	    merge_rfm_result self.class.create_from_new(@mods)
+  	    # merge_rfm_result self.class.create_from_new(@mods)
+  	    replace_with_fresh_data self.class.create_from_new(@mods)
   	  end
   	  self
   	end
@@ -417,26 +282,28 @@ module Rfm
   	    return unless @mods.size > 0
   	    unless mod_id
   	      # regular save
-  	      merge_rfm_result self.class.send :edit, record_id, @mods
+  	      # merge_rfm_result self.class.send :edit, record_id, @mods
+  	      replace_with_fresh_data self.class.send :edit, record_id, @mods
 	      else
 	        # save_if_not_modified
-	        merge_rfm_result self.class.send :edit, record_id, @mods, :modification_id=>mod_id
+	        # merge_rfm_result self.class.send :edit, record_id, @mods, :modification_id=>mod_id
+	        replace_with_fresh_data self.class.send :edit, record_id, @mods, :modification_id=>mod_id
         end
   	  end
   	  self
   	end
   	
+  	# Deprecated in favor of Record#replace_with_fresh_data
   	def merge_rfm_result(result_record)
       return unless @mods.size > 0
       @record_id ||= result_record.record_id
       self.merge! result_record
       @mods.clear
       self || {}
+      #self || Rfm::CaseInsensitiveHash.new
     end
     
   end # Base
 
 end # Rfm
 
-
-