ginjo-rfm 2.0.2 → 2.1.0.pre02

data/lib/rfm.rb

@@ -32,6 +32,10 @@ module Rfm
   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'
 
 	module Metadata
 		autoload :Script,         'rfm/metadata/script'

data/lib/rfm/VERSION

@@ -1 +1 @@
-2.0.2
+2.1.0.pre02

data/lib/rfm/base.rb

@@ -43,6 +43,9 @@ module Rfm
   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
 
@@ -79,6 +82,10 @@ module Rfm
 	    		@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
@@ -172,7 +179,7 @@ module Rfm
     end
     
 		def initialize(record={}, resultset_obj=[], field_meta='', layout_obj=self.class.layout, portal=nil)
-			if resultset_obj == [] and !record.has_key? 'field'
+			if resultset_obj == [] and !record.respond_to?(:columns) #.has_key? 'field'
 				@mods = Rfm::CaseInsensitiveHash.new
 				@layout = layout_obj
 				@resultset = Resultset.allocate
@@ -219,10 +226,20 @@ module Rfm
 	  		return @layout if @layout
 	  		cnf = get_config
 	  		return unless cnf[:layout]
-	  		@layout = Rfm::Factory.layout(get_config).sublayout
+	  		@layout = Rfm::Factory.layout(cnf).sublayout
+	  		
+	  		# Added by wbr to give config heirarchy: layout -> model -> sublayout
+	  		config :parent=>'parent_layout'
+	  		@layout.config :parent=>'model'
+	  		
 				@layout.model = self
 				@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={})

data/lib/rfm/database.rb

@@ -58,6 +58,7 @@ module Rfm
   # * *name* is the name of this database
   # * *state* is a hash of all server options used to initialize this server
   class Database
+  	include Config
   
     # Initialize a database object. You never really need to do this. Instead, just do this:
     # 
@@ -65,21 +66,40 @@ module Rfm
     #   myDatabase = myServer["Customers"]
     #
     # This sample code gets a database object representing the Customers database on the FileMaker server.
-    def initialize(name, server_obj, acnt=nil, pass=nil)
-    	raise Rfm::Error::RfmError.new(0, "New instance of Rfm::Database has no name. Attempted name '#{name}'.") if name.to_s == ''
-      @name = name.to_s
-      rfm_metaclass.instance_variable_set :@server, server_obj
-      @account_name = acnt #server.state[:account_name] or ""
-      @password = pass #server.state[:password] or ""
-      @layout = Rfm::Factory::LayoutFactory.new(server, self)
-      @script = Rfm::Factory::ScriptFactory.new(server, self)
+    def initialize(*args) #name, server_obj, acnt=nil, pass=nil
+    	options = get_config(*args)
+    	rfm_metaclass.instance_variable_set :@server, (options[:objects].delete_at(0) || options[:server_object])
+    	options = get_config(options)
+    	
+    	config sanitize_config(options, {}, true)
+    	config :parent=> 'server'
+    	config :database=> options[:strings].delete_at(0) || options[:database]
+    	config :account_name=> options[:strings].delete_at(0) || options[:account_name]
+    	config :password=> options[:strings].delete_at(0) || options[:password]
+      
+      raise Rfm::Error::RfmError.new(0, "New instance of Rfm::Database has no name. Attempted name '#{state[:database]}'.") if state[:database].to_s == ''
+            
+      @layouts = Rfm::Factory::LayoutFactory.new(server, self)
+      @scripts = Rfm::Factory::ScriptFactory.new(server, self)
     end
     
     meta_attr_reader :server
-    #attr_reader :server
-    attr_reader :name, :account_name, :password, :layout, :script
-    attr_writer :account_name, :password
-    alias_method :layouts, :layout
+    attr_reader :layouts, :scripts
+    # Not sure if these writers are ever used
+    #attr_writer :account_name, :password
+    # Legacy methods
+    alias_method :layout, :layouts
+    alias_method :script, :scripts
+    
+    def name; state[:database].to_s; end
+    def account_name; state[:account_name]; end
+    def account_name=(x); config :account_name=>x; end
+    def password; state[:password]; end
+    def password=(x); config :password=>x; end
+    
+		def state(*args)
+			get_config(*args)
+		end
 
     # Access the Layout object representing a layout in this database. For example:
     #
@@ -95,7 +115,7 @@ module Rfm
 		#     def [](layout_name)
 		#       self.layout[layout_name]
 		#     end
-    def_delegator :layout, :[]
+    def_delegator :layouts, :[]
 
   end
 end

data/lib/rfm/layout.rb

@@ -119,6 +119,7 @@ module Rfm
   #   list that is attached to any field on the layout
   
   class Layout
+	  include Config
 		    
     # Initialize a layout object. You never really need to do this. Instead, just do this:
     # 
@@ -133,32 +134,44 @@ module Rfm
     #
     #   myServer = Rfm::Server.new(...)
     #   myLayout = myServer["Customers"]["Details"]
-    def initialize(name, db_obj)
-    	raise Rfm::Error::RfmError.new(0, "New instance of Rfm::Layout has no name. Attempted name '#{name}'.") if name.to_s == ''
-      @name = name.to_s
-      rfm_metaclass.instance_variable_set :@db, db_obj
-      
+    def initialize(*args) #name, db_obj
+    	options = get_config(*args)
+    	rfm_metaclass.instance_variable_set :@db, (options[:objects].delete_at(0) || options[:database_object])
+    	config :parent=> 'db'
+    	options = get_config(options)
+    	
+    	config sanitize_config(options, {}, true)
+    	config :layout => options[:strings].delete_at(0) || options[:layout]
+    
+    	raise Rfm::Error::RfmError.new(0, "New instance of Rfm::Layout has no name. Attempted name '#{state[:layout]}'.") if state[:layout].to_s == ''
+                  
       @loaded = false
       @field_controls = Rfm::CaseInsensitiveHash.new
       @value_lists = Rfm::CaseInsensitiveHash.new
-			#       @portal_meta = nil
-			#       @field_names = nil
-			@ignore_bad_data = (db_obj.server.state[:ignore_bad_data] rescue nil)
+			#	@portal_meta = nil
+			#	@field_names = nil
+			#@ignore_bad_data = (db_obj.server.state[:ignore_bad_data] rescue nil)
     end
     
     meta_attr_reader :db
-    attr_reader :name #, :db
+    #attr_reader :name #, :db
     attr_writer :field_names, :portal_meta, :table
     def_delegator :db, :server
     alias_method :database, :db
-    
+		
+		# This method may be obsolete, since the option can now be set with #config.
+    def ignore_bad_data(val = nil)
+    	(config :ignore_bad_data => val) unless val.nil?
+    	state[:ignore_bad_data]
+    end
     
     # These methods are to be inclulded in Layout and SubLayout, so that
-    # they have their own descrete 'self' in the master class and the subclass.
+    # they have their own discrete 'self' in the master class and the subclass.
     # This means these methods will not get forwarded, and will talk to the correct
     # variables & objects of the correct self.
     # Do not get or set instance variables in Layout from other objects directly,
     # always use getter & setter methods.
+    # This all means that any chain of methods that want to refer ultimately to Sublayout, must all be defined or included in Sublayout
     module LayoutModule
     
 	    # Returns a ResultSet object containing _every record_ in the table associated with this layout.
@@ -251,9 +264,13 @@ module Rfm
 	    end
 	    
 	    def get_records(action, extra_params = {}, options = {})
+	    	# The grammar stuff here won't work properly until you handle config between models/sublayouts/layout/server.
+	    	grammar_option = state(options)[:grammar]
+	    	options.merge!(:grammar=>grammar_option) if grammar_option
 	      include_portals = options[:include_portals] ? options.delete(:include_portals) : nil
-	      xml_response = db.server.connect(db.account_name, db.password, action, params.merge(extra_params), options).body
-	      Rfm::Resultset.new(db.server, xml_response, self, include_portals)
+	      xml_response = server.connect(state[:account_name], state[:password], action, params.merge(extra_params), options).body
+	      #Rfm::Resultset.new(db.server, xml_response, self, include_portals)
+	      Rfm::Resultset.new(xml_response, self, include_portals)
 	    end
 	    
 	    def params
@@ -281,9 +298,35 @@ module Rfm
 				end
 				hash
 			end
+
+	    def name; state[:layout].to_s; end
 	    
+			def state(*args)
+				get_config(*args)
+			end
+
 	  end # LayoutModule
+	  
 	  include LayoutModule
+	  
+	  
+    ###
+		def view_meta
+			@view_meta ||= view
+		end
+		def date_format
+			@date_format ||= view_meta.date_format
+		end
+		def time_format
+			@time_format ||= view_meta.time_format
+		end		
+		def timestamp_format
+			@timestamp_format ||= view_meta.timestamp_format
+		end
+		def field_meta
+			@field_meta ||= view_meta.field_meta
+		end
+		###
     
     
     def field_controls
@@ -377,11 +420,6 @@ module Rfm
       @field_controls.freeze
     end
     
-    def ignore_bad_data(val = nil)
-    	(@ignore_bad_data = val) unless val.nil?
-    	@ignore_bad_data
-    end
-    
   	private :load, :get_records, :params
       
       

data/lib/rfm/metadata/field.rb

@@ -64,11 +64,11 @@ module Rfm
       # Initializes a field object. You'll never need to do this. Instead, get your Field objects from
       # ResultSet::fields
       def initialize(field)
-        @name        = field['name']
-        @result      = field['result']
-        @type        = field['type']
-        @max_repeats = field['max-repeats']
-        @global      = field['global']
+        @name        = field.name #['name']
+        @result      = field.result #['result']
+        @type        = field.type #['type']
+        @max_repeats = field.max_repeats #['max-repeats']
+        @global      = field.global #['global']
       end
     
       # Coerces the text value from an +fmresultset+ document into proper Ruby types based on the 
@@ -76,7 +76,7 @@ module Rfm
       # access field data through the Record object.
       def coerce(value, resultset)
         return nil if (value.nil? or value.empty?)
-        case self.result
+        case self.result.downcase
         when "text"      then value
         when "number"    then BigDecimal.new(value)
         when "date"      then Date.strptime(value, resultset.date_format)

data/lib/rfm/record.rb

@@ -114,27 +114,26 @@ module Rfm
     def_delegators :layout, :db, :database, :server
 
     def initialize(record, resultset_obj, field_meta, layout_obj, portal=nil)
-
+    
       @layout        = layout_obj
       @resultset     = resultset_obj
-      @record_id     = record['record-id']
-      @mod_id        = record['mod-id']
+      @record_id     = record.record_id rescue nil
+      @mod_id        = record.mod_id rescue nil
       @mods          = {}
       @portals     ||= Rfm::CaseInsensitiveHash.new
 
-      relatedsets = !portal && resultset_obj.instance_variable_get(:@include_portals) ? record['relatedset'].rfm_force_array : []
-            
-      record['field'].rfm_force_array.each do |field|
+      relatedsets = !portal && resultset_obj.instance_variable_get(:@include_portals) ? record.portals : []
+      
+      record.columns.each do |field|
       	next unless field
-        field_name = field['name']
+        field_name = field.name
         field_name.gsub!(Regexp.new(portal + '::'), '') if portal
         datum = []
-        
-        data = field['data']; data = data.is_a?(Hash) ? [data] : data
+        data = field.data #['data']; data = data.is_a?(Hash) ? [data] : data
         data.each do |x|
         	next unless field_meta[field_name]
         	begin
-	          datum.push(field_meta[field_name].coerce(x['__content__'], resultset_obj))
+	          datum.push(field_meta[field_name].coerce(x, resultset_obj)) #(x['__content__'], resultset_obj))
         	rescue StandardError => error
         		self.errors.add(field_name, error) if self.respond_to? :errors
         		raise error unless @layout.ignore_bad_data
@@ -153,9 +152,9 @@ module Rfm
       unless relatedsets.empty?
         relatedsets.each do |relatedset|
         	next if relatedset.blank?
-          tablename, records = relatedset['table'], []
+          tablename, records = relatedset.table, []
       
-          relatedset['record'].rfm_force_array.each do |record|
+          relatedset.records.each do |record|
           	next unless record
             records << self.class.new(record, resultset_obj, resultset_obj.portal_meta[tablename], layout_obj, tablename)
           end
@@ -223,15 +222,39 @@ module Rfm
       super
     end
     
-
     def []=(key, value)
       key_string = key.to_s.downcase
       return super unless @loaded # is this needed?
       raise Rfm::ParameterError, "You attempted to modify a field that does not exist in the current Filemaker layout." unless self.key?(key_string)
-      @mods[key_string] = value
+      # @mods[key_string] = value
+      # TODO: This needs cleaning up.
+      # TODO: can we get field_type from record instead?
+			@mods[key_string] = if [Date, Time, DateTime].member?(value.class)
+				field_type = layout.field_meta[key_string.to_sym].result
+				case field_type
+					when 'time'; val.strftime(layout.time_format)
+					when 'date'; val.strftime(layout.date_format)
+					when 'timestamp'; val.strftime(layout.timestamp_format)
+				else value
+				end
+			else value
+			end
       super(key, value)
     end
-    
+		#
+		# 		alias_method :old_setter, '[]='
+		# 		def []=(key,val)
+		# 			old_setter(key,val)
+		# 			return val unless [Date, Time, DateTime].member? val.class
+		# 			field_type = layout.field_meta[key.to_sym].result
+		# 			@mods[key] = case field_type
+		# 				when 'time'; val.strftime(layout.time_format)
+		# 				when 'date'; val.strftime(layout.date_format)
+		# 				when 'timestamp'; val.strftime(layout.timestamp_format)
+		# 				else val
+		# 			end
+		# 		end  
+		  
 	  def field_names
     	resultset.field_names rescue layout.field_names
     end

data/lib/rfm/resultset.rb

@@ -36,12 +36,18 @@ module Rfm
   #   it provides metadata about the portals in the ResultSet and the Fields on those portals
 
   class Resultset < Array
+  	include Config
     
-    attr_reader :layout, :server
-    attr_reader :field_meta, :portal_meta
+    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
-    def_delegators :layout, :db, :database
+    #def_delegators :layout, :db, :database
+    alias_method :db, :database
+    
+    class << self
+    	alias_method :load_data, :new
+    end
     
     # Initializes a new ResultSet object. You will probably never do this your self (instead, use the Layout
     # object to get various ResultSet obejects).
@@ -64,53 +70,72 @@ 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(server_obj, xml_response, layout_obj, portals=nil)
-      @layout           = layout_obj
-      @server           = server_obj
-      @field_meta     ||= Rfm::CaseInsensitiveHash.new
-      @portal_meta    ||= Rfm::CaseInsensitiveHash.new
-      @include_portals  = portals 
+    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)
       
-      doc = XmlParser.new(xml_response, :namespace=>false, :parser=>(server.state[:parser] rescue nil))
+      xml_response			= args[0] || options[:xml_response]
+      doc = XmlParser.parse(xml_response, :namespace=>false, :parser=>(state[:parser] rescue nil))
       
-      error = doc['fmresultset']['error']['code'].to_i
+      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['fmresultset']['datasource']
-      meta              = doc['fmresultset']['metadata']
-      resultset         = doc['fmresultset']['resultset']
+      @datasource       = doc.datasource
+      meta              = doc.meta
+      resultset         = doc.resultset
 
-      @date_format      = convert_date_time_format(@datasource['date-format'].to_s)
-      @time_format      = convert_date_time_format(@datasource['time-format'].to_s)
-      @timestamp_format = convert_date_time_format(@datasource['timestamp-format'].to_s)
+      @date_format      = doc.date_format
+      @time_format      = doc.time_format
+      @timestamp_format = doc.timestamp_format
 
-      @foundset_count   = resultset['count'].to_s.to_i
-      @total_count      = @datasource['total-count'].to_s.to_i
-      @table            = @datasource['table']
-      
+      @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(meta)
+      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(meta)
+      parse_portals(doc)
       
       # These were added for loading resultset from file
-      unless @layout
-      	@layout = @datasource['layout']
-      	@layout.instance_variable_set '@database', @datasource['database']
-      	@layout.instance_eval do
-      		def database
-      			@database
-      		end
-      	end
-      end			
+      # 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 resultset['record'].nil?
-      Rfm::Record.build_records(resultset['record'].rfm_force_array, self, @field_meta, @layout)
+      return if doc.records.blank?
+      Rfm::Record.build_records(doc.records, self, @field_meta, @layout)
     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)
+		end
         
     def field_names
     	field_meta.collect{|k,v| v.name}
@@ -120,34 +145,29 @@ module Rfm
   		portal_meta.keys
   	end
     
-    # Load Resultset data from file-spec or string
-    def self.load_data(file_or_string)
-    	self.new(nil, file_or_string, nil)
-    end
-    
     private
     
       def check_for_errors(code, raise_401)
         raise Rfm::Error.getError(code) if code != 0 && (code != 401 || raise_401)
       end
     
-      def parse_fields(meta)
-      	return if meta['field-definition'].blank?
+      def parse_fields(doc)
+      	return if doc.fields.blank?
 
-        meta['field-definition'].rfm_force_array.each do |field|
-          @field_meta[field['name']] = Rfm::Metadata::Field.new(field)
+        doc.fields.each do |field|
+          @field_meta[field.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(meta)
-      	return if meta['relatedset-definition'].blank?
-        meta['relatedset-definition'].rfm_force_array.each do |relatedset|
+      def parse_portals(doc)
+      	return if doc.portals.blank?
+        doc.portals.each do |relatedset|
         	next if relatedset.blank?
-          table, fields = relatedset['table'], {}
+          table, fields = relatedset.table, {}
 
-          relatedset['field-definition'].rfm_force_array.each do |field|
-            name = field['name'].to_s.gsub(Regexp.new(table + '::'), '')
+          relatedset.fields.each do |field|
+            name = field.name.to_s.gsub(Regexp.new(table + '::'), '')
             fields[name] = Rfm::Metadata::Field.new(field)
           end
 
@@ -156,15 +176,15 @@ module Rfm
         (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