ginjo-rfm 2.1.7 → 3.0.0

data/lib/rfm/metadata/datum.rb

@@ -0,0 +1,45 @@
+require 'delegate'
+module Rfm
+  module Metadata
+  
+    class Datum   #< DelegateClass(Field)
+    
+      def get_mapped_name(name, resultset)
+      	(resultset && resultset.layout && resultset.layout.field_mapping[name]) || name
+      end
+      
+			def main_callback(cursor)
+				resultset = cursor.top.object
+				name = get_mapped_name(@attributes['name'].to_s, resultset)
+				field = resultset.field_meta[name]
+				data = @attributes['data']
+				cursor.parent.object[name.downcase] = field.coerce(data)
+			end
+			
+			def portal_callback(cursor)
+				resultset = cursor.top.object
+				table, name = @attributes['name'].to_s.split('::')
+				#puts ['DATUM_portal_callback_01', table, name].join(', ')
+				name = get_mapped_name(name, resultset)
+				field = resultset.portal_meta[table.downcase][name.downcase]
+				data = @attributes['data']
+				#puts ['DATUM_portal_callback_02', resultset.class, table, name, field, data].join(', ')
+				#(y resultset.portal_meta) unless field
+				cursor.parent.object[name.downcase] = field.coerce(data)
+			end
+      
+      # Should return value only.
+			def handler_callback(cursor)
+				record = cursor.parent.object
+				resultset = cursor.top.object
+
+				name = get_mapped_name(@attributes['name'].to_s, resultset)
+				field = resultset.field_meta[name]
+				data = @attributes['data']
+				#puts ["\nDATUM", name, record.class, resultset.class, data]
+				record[name] = field.coerce(data)
+			end
+      
+    end # Field
+  end # Metadata
+end # Rfm

data/lib/rfm/metadata/field.rb

@@ -60,33 +60,53 @@ module Rfm
     class Field
       
       attr_reader :name, :result, :type, :max_repeats, :global
-      
+      meta_attr_accessor :resultset
       # Initializes a field object. You'll never need to do this. Instead, get your Field objects from
-      # ResultSet::fields
-      def initialize(field, options={})
-        @name        = options[:field_mapping][field.name] || field.name rescue field.name #['name']
-        @result      = field.result #['result']
-        @type        = field.type #['type']
-        @max_repeats = field.max_repeats #['max-repeats']
-        @global      = field.global #['global']
-      end
+      # Resultset::field_meta
+			def initialize(attributes)
+				_attach_as_instance_variables attributes
+				self
+			end
     
       # Coerces the text value from an +fmresultset+ document into proper Ruby types based on the 
       # type of the field. You'll never need to do this: Rfm does it automatically for you when you
       # access field data through the Record object.
-      def coerce(value, resultset)
+      def coerce(value)
         return nil if (value.nil? or value.empty?)
-        case self.result.downcase
+        case result
         when "text"      then value
         when "number"    then BigDecimal.new(value.to_s)
         when "date"      then Date.strptime(value, resultset.date_format)
         when "time"      then DateTime.strptime("1/1/-4712 #{value}", "%m/%d/%Y #{resultset.time_format}")
         when "timestamp" then DateTime.strptime(value, resultset.timestamp_format)
-        when "container" then URI.parse("#{resultset.server.scheme}://#{resultset.server.host_name}:#{resultset.server.port}#{value}")
+        when "container" then
+        	resultset_meta = resultset.instance_variable_get(:@meta)
+        	if resultset_meta && resultset_meta['doctype'] && value.to_s[/\?/]
+        		URI.parse(resultset_meta['doctype'].last.to_s).tap{|uri| uri.path, uri.query = value.split('?')}
+        	else
+        		value
+        	end
         else nil
         end
-        
+#       rescue
+#         puts("ERROR in Field#coerce:", name, value, result, $!)
+#         nil
+      end
+      
+      def get_mapped_name
+      	(resultset && resultset.layout && resultset.layout.field_mapping[name]) || name
       end
+            
+			def main_callback(cursor)
+				self.resultset = cursor.top.object
+				resultset.field_meta[get_mapped_name.to_s.downcase] = self
+			end
+			
+			def portal_callback(cursor)
+				self.resultset = cursor.top.object
+				cursor.parent.object[get_mapped_name.split('::').last.to_s.downcase] = self
+				#puts ['FIELD_portal_callback', name, cursor.parent.object.object_id, cursor.parent.tag, cursor.parent.object[name.split('::').last.to_s.downcase]].join(', ')
+			end
       
     end # Field
   end # Metadata

data/lib/rfm/metadata/field_control.rb

@@ -22,33 +22,65 @@ module Rfm
 	  # * *value_list* is an array of strings representing the value list items, or nil
 	  #   if this field has no attached value list
 	  class FieldControl
-	    def initialize(name, style, value_list_name, value_list)
-	      @name = name
-	      case style
-	      when "EDITTEXT"
-	        @style = :edit_box
-	      when "POPUPMENU"
-	        @style = :popup_menu
-	      when "CHECKBOX"
-	        @style = :checkbox_set
-	      when "RADIOBUTTONS"
-	        @style = :radio_button_set
-	      when "POPUPLIST"
-	        @style = :popup_list
-	      when "CALENDAR"
-	        @style = :calendar
-	      when "SCROLLTEXT"
-	        @style = :scrollable
-	      else
-	        nil
-	      end
-	      @value_list_name = value_list_name
-	      rfm_metaclass.instance_variable_set :@value_list, value_list
-	    end
-	    
 	    attr_reader :name, :style, :value_list_name
-	    meta_attr_reader :value_list
+	    meta_attr_accessor :layout_meta
 	  
+	  	def initialize(attributes, meta)
+	  		self.layout_meta = meta
+	  		_attach_as_instance_variables attributes
+	  		self
+	  	end
+	  	
+	  	# Handle manual attachment of STYLE element.
+	  	def handle_style_element(attributes)
+	  		_attach_as_instance_variables attributes, :key_translator=>method(:translate_value_list_key), :value_translator=>method(:translate_style_value)
+	  	end
+	  	
+	  	def translate_style_value(raw)
+	  		#puts ["TRANSLATE_STYLE", raw].join(', ')
+	  		{
+	  			'EDITTEXT'	=>	:edit_box,
+					'POPUPMENU'	=>	:popup_menu,
+					'CHECKBOX'	=>	:checkbox_set,
+					'RADIOBUTTONS'	=>	:radio_button_set,
+					'POPUPLIST'	=>	:popup_list,
+					'CALENDAR'	=>	:calendar,
+					'SCROLLTEXT'	=>	:scrollable,
+	  		}[raw] || raw
+	  	end
+	  	
+	  	def translate_value_list_key(raw)
+				{'valuelist'=>'value_list_name'}[raw] || raw	  	
+	  	end
+	  	
+	  	def value_list
+	  		layout_meta.value_lists[value_list_name]
+	  	end
+	  
+			#   def initialize(name, style, value_list_name, value_list)
+			#     @name = name
+			#     case style
+			#     when "EDITTEXT"
+			#       @style = :edit_box
+			#     when "POPUPMENU"
+			#       @style = :popup_menu
+			#     when "CHECKBOX"
+			#       @style = :checkbox_set
+			#     when "RADIOBUTTONS"
+			#       @style = :radio_button_set
+			#     when "POPUPLIST"
+			#       @style = :popup_list
+			#     when "CALENDAR"
+			#       @style = :calendar
+			#     when "SCROLLTEXT"
+			#       @style = :scrollable
+			#     else
+			#       nil
+			#     end
+			#     @value_list_name = value_list_name
+			#     rfm_metaclass.instance_variable_set :@value_list, value_list
+			#   end
+
 	  end
 	end
 end

data/lib/rfm/metadata/layout_meta.rb

@@ -0,0 +1,38 @@
+module Rfm
+	module Metadata
+		class LayoutMeta < CaseInsensitiveHash
+			
+			def initialize(layout)
+				@layout = layout
+			end
+			
+	    def field_controls
+	      self['field_controls'] ||= CaseInsensitiveHash.new
+	    end
+	    
+	  	def field_names
+	  		field_controls.values.collect{|v| v.name}
+	  	end
+			
+	  	def field_keys
+	  		field_controls.keys
+	  	end
+	  	
+	    def value_lists
+				self['value_lists'] ||= CaseInsensitiveHash.new
+	    end
+	    
+			def handle_new_field_control(attributes)
+				name = attributes['name']
+				field_control = FieldControl.new(attributes, self)
+				field_controls[get_mapped_name(name)] = field_control
+			end
+			
+			# Should this be in FieldControl object?
+      def get_mapped_name(name)
+      	(@layout.field_mapping[name]) || name
+      end
+		
+		end
+	end
+end

data/lib/rfm/metadata/resultset_meta.rb

@@ -0,0 +1,66 @@
+module Rfm
+	module Metadata
+		class ResultsetMeta < CaseInsensitiveHash
+			
+			def field_meta
+				self['field_meta'] ||= CaseInsensitiveHash.new
+			end
+			
+			def portal_meta
+				self['portal_meta'] ||= CaseInsensitiveHash.new
+			end
+			
+			def date_format
+				self['date_format']
+			end
+	
+			def time_format
+				self['time_format']
+			end
+			
+			def timestamp_format
+				self['timestamp_format']
+			end
+			
+			def total_count
+				self['total_count'].to_i
+			end		
+			
+			def foundset_count
+				self['count'].to_i
+			end
+			
+			def fetch_size
+				self['fetch_size'].to_i
+			end
+			
+			def table
+				self['table']
+			end
+			
+			def error
+				self['error']
+			end
+	        
+	    def field_names
+	    	field_meta ? field_meta.values.collect{|v| v.name} : []
+	  	end
+	  	
+	    def field_keys
+	    	field_meta ? field_meta.keys : []
+	  	end
+	  	
+	  	def portal_names
+	  		portal_meta ? portal_meta.keys : []
+	  	end
+						
+	  	def handle_new_field(attributes)
+	  		f = Field.new(attributes)
+	  		# TODO: Re-enable these when you stop using the before_close callback.
+				# 	name = attributes['name']
+				# 	self[name] = f
+	  	end
+		
+		end
+	end
+end

data/lib/rfm/metadata/value_list_item.rb

@@ -15,14 +15,15 @@ module Rfm
 	  #
 	  # * *#value_list_name* is the name of the parent value list, if any
 	  class ValueListItem < String
+	  	# TODO: re-instate saving of value_list_name.
 	    attr_reader :value, :display, :value_list_name
 	    
-	    def initialize(value, display, value_list_name)
-	      @value_list_name = value_list_name
-	      @value					 = value.to_s
-	      @display				 = display.to_s
-	      self.replace @value
-	    end
+			#   def initialize(value, display, value_list_name)
+			#     @value_list_name = value_list_name
+			#     @value					 = value.to_s
+			#     @display				 = display.to_s
+			#     self.replace @value
+			#   end
 	  
 	  end # ValueListItem
 	  

data/lib/rfm/record.rb

@@ -108,68 +108,48 @@ module Rfm
   #   copy of the same record
   class Record < Rfm::CaseInsensitiveHash
     
-    attr_accessor :layout, :resultset
+    attr_accessor :layout #, :resultset
     attr_reader :record_id, :mod_id, :portals
-    def_delegators :resultset, :field_meta, :portal_names
-    def_delegators :layout, :db, :database, :server
-
-    def initialize(record, resultset_obj, field_meta, layout_obj, portal=nil)
+    def_delegators :layout, :db, :database, :server, :field_meta, :portal_meta, :field_names, :portal_names
     
-      @layout        = layout_obj
-      @resultset     = resultset_obj
-      @record_id     = record.record_id rescue nil
-      @mod_id        = record.mod_id rescue nil
-      @mods          = {}
-      @portals     ||= Rfm::CaseInsensitiveHash.new
+    # This is called during the parsing process, but only to allow creation of the correct type of model instance.
+    # This is also called by the end-user when constructing a new empty record, but it is called from the model subclass.
+		def self.new(*args) # resultset
+			record = case
+			
+			# Get model from layout, then allocate record.
+			when args[0].is_a?(Resultset) && args[0].layout
+				args[0].layout.modelize.allocate
+			
+			# Allocate instance of Rfm::Record.	
+			else
+				self.allocate
+			end
+			record.send(:initialize, *args)
+			record
+			# rescue
+			# 	puts "Record.new bombed and is defaulting to super.new. Error: #{$!}"
+			# 	super
+		end
 
-      relatedsets = !portal && resultset_obj.instance_variable_get(:@include_portals) ? record.portals : []
-      
-      record.columns.each do |field|
-      	next unless field
-        field_name = @layout.field_mapping[field.name] || field.name rescue field.name
-        field_name.gsub!(Regexp.new(portal + '::'), '') if portal
-        datum = []
-        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, 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
-        	end
-        end if data
-      
-        if datum.length == 1
-          rfm_super[field_name] = datum[0]
-        elsif datum.length == 0
-          rfm_super[field_name] = nil
-        else
-          rfm_super[field_name] = datum
+    def initialize(*args) # resultset, attributes
+      @mods						||= {}
+      @portals        ||= Rfm::CaseInsensitiveHash.new
+			options = args.rfm_extract_options!
+			if args[0].is_a?(Resultset)
+				@layout = args[0].layout
+			elsif self.is_a?(Base)
+				@layout = self.class.layout
+        @layout.field_keys.each do |field|
+          self[field] = nil
         end
+        self.update_attributes(options) unless options == {}
+        self.merge!(@mods) unless @mods == {}
+        @loaded = true
       end
-      
-      unless relatedsets.empty?
-        relatedsets.each do |relatedset|
-        	next if relatedset.blank?
-          tablename, records = relatedset.table, []
-      
-          relatedset.records.each do |record|
-          	next unless record
-            records << self.class.new(record, resultset_obj, resultset_obj.portal_meta[tablename], layout_obj, tablename)
-          end
-      
-          @portals[tablename] = records
-        end
-      end
-      
-      @loaded = true
-    end
-
-    def self.build_records(records, resultset_obj, field_meta, layout_obj, portal=nil)
-      records.each do |record|
-        resultset_obj << self.new(record, resultset_obj, field_meta, layout_obj, portal)
-      end
+      _attach_as_instance_variables args[1]
+			#@loaded = true
+			self
     end
 
     # Saves local changes to the Record object back to Filemaker. For example:
@@ -186,7 +166,8 @@ module Rfm
     # to optimize on your end. Just save, and if you've changed the record it will be saved. If not, no
     # server hit is incurred.
     def save
-      self.merge!(layout.edit(self.record_id, @mods)[0]) if @mods.size > 0
+      # self.merge!(layout.edit(self.record_id, @mods)[0]) if @mods.size > 0
+      self.replace_with_fresh_data(layout.edit(self.record_id, @mods)[0]) if @mods.size > 0
       @mods.clear
     end
 
@@ -194,7 +175,8 @@ module Rfm
     # modified after the record was fetched but before it was saved. In other words, prevents you from
     # accidentally overwriting changes someone else made to the record.
     def save_if_not_modified
-      self.merge!(layout.edit(@record_id, @mods, {:modification_id => @mod_id})[0]) if @mods.size > 0
+      # self.merge!(layout.edit(@record_id, @mods, {:modification_id => @mod_id})[0]) if @mods.size > 0
+      self.replace_with_fresh_data(layout.edit(@record_id, @mods, {:modification_id => @mod_id})[0]) if @mods.size > 0
       @mods.clear
     end
     
@@ -212,6 +194,8 @@ module Rfm
     # When you do, the change is noted, but *the data is not updated in FileMaker*. You must call
     # Record::save or Record::save_if_not_modified to actually save the data.
   	def [](key)
+  		# Added by wbr, 2013-03-31
+  		return super unless @loaded
   		return fetch(key.to_s.downcase)
   	rescue IndexError
     	raise Rfm::ParameterError, "#{key} does not exists as a field in the current Filemaker layout." unless key.to_s == '' #unless (!layout or self.key?(key_string))
@@ -241,24 +225,20 @@ module Rfm
 			end
       super(key, val)
     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
+    	layout.field_names
     end
-
+    
+    def replace_with_fresh_data(record)
+			self.replace record
+			[:@mod_id, :@record_id, :@portals, :@mods].each do |var|
+				self.instance_variable_set var, record.instance_variable_get(var) || {}
+			end
+			self
+		end
+		
+		
 
   private