ginjo-rfm 2.1.7 → 3.0.0

data/lib/rfm/database.rb

@@ -67,23 +67,13 @@ module Rfm
     #
     # This sample code gets a database object representing the Customers database on the FileMaker server.
     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]
-      
+			config(*args)
       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
+    meta_attr_accessor :server
     attr_reader :layouts, :scripts
     # Not sure if these writers are ever used
     #attr_writer :account_name, :password
@@ -97,9 +87,18 @@ module Rfm
     def password; state[:password]; end
     def password=(x); config :password=>x; end
     
-		def state(*args)
-			get_config(*args)
-		end
+    def config(*args)
+    	super(:capture_strings_with=>[:database, :account_name, :password])
+    	super(*args) do |params|
+    		(self.server = params[:objects][0]) if params && params[:objects] && params[:objects][0] && params[:objects][0].is_a?(Rfm::Server)
+    	end
+    end
+    
+    alias_method :server_orig, :server
+  	def server
+  		server_orig || (self.server = Rfm::Server.new(state[:host], state[:account_name], state[:password], self))
+  	end
+    
 
     # Access the Layout object representing a layout in this database. For example:
     #
@@ -115,7 +114,7 @@ module Rfm
 		#     def [](layout_name)
 		#       self.layout[layout_name]
 		#     end
-    def_delegator :layouts, :[]
+    def_delegators :layouts, :[], :modelize, :models # modelize & models acquired from Rfm::Base
 
   end
 end

data/lib/rfm/layout.rb

@@ -1,3 +1,4 @@
+require 'delegate'
 module Rfm
   # The Layout object represents a single FileMaker Pro layout. You use it to interact with 
   # records in FileMaker. *All* access to FileMaker data is done through a layout, and this
@@ -120,6 +121,41 @@ module Rfm
   
   class Layout
 	  include Config
+
+    meta_attr_accessor :db
+    attr_reader :field_mapping
+    attr_writer :resultset_meta
+    def_delegator :db, :server
+    #alias_method :database, :db  # This fails if db object hasn't been set yet with meta_attr_accessor
+    def database; db; end
+    attr_accessor :model #, :parent_layout, :subs
+    def_delegators :meta, :field_controls, :value_lists
+    def_delegators :resultset_meta, :date_format, :time_format, :timestamp_format, :field_meta, :portal_meta, :table
+
+		# Methods that must be kept after rewrite!!!
+		# 	  
+		# field_mapping
+		# db (database)
+		# name
+		# resultset_meta
+		# date_format
+		# time_format
+		# timestamp_format
+		# field_meta
+		# field_controls
+		# field_names
+		# field_names_no_load
+		# value_lists
+		# count
+		# total_count
+		# portal_meta
+		# portal_meta_no_load
+		# portal_names
+		# table
+		# table_no_load
+		# server
+	  
+	  
 		    
     # Initialize a layout object. You never really need to do this. Instead, just do this:
     # 
@@ -135,305 +171,219 @@ module Rfm
     #   myServer = Rfm::Server.new(...)
     #   myLayout = myServer["Customers"]["Details"]
     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 == ''
-                  
+#     	self.subs ||= []
+			config(*args)
+    	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)
+      @meta = Metadata::LayoutMeta.new(self)
+      self
     end
-    
-    meta_attr_reader :db
-    attr_reader :field_mapping
-    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]
+
+    def config(*args)
+    	super(:capture_strings_with=>[:layout])
+    	super(*args) do |params|
+    		(self.name = params[:strings][0]) if params && params[:strings] && params[:strings].any?
+    		(self.db = params[:objects][0]) if params && params[:objects] && params[:objects][0] && params[:objects][0].is_a?(Rfm::Database)
+    	end
     end
     
-    # These methods are to be inclulded in Layout and SubLayout, so that
-    # 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
+    alias_method :db_orig, :db
+  	def db
+  		db_orig || (self.db = Rfm::Database.new(state[:database], state[:account_name], state[:password], self))
+  	end
     
-	    # Returns a ResultSet object containing _every record_ in the table associated with this layout.
-	    def all(options = {})
-	      get_records('-findall', {}, options)
-	    end
-	    
-	    # Returns a ResultSet containing a single random record from the table associated with this layout.
-	    def any(options = {})
-	      get_records('-findany', {}, options)
-	    end
-	  
-	    # Finds a record. Typically you will pass in a hash of field names and values. For example:
-	    #
-	    #   myLayout.find({"First Name" => "Bill"})
-	    #
-	    # Values in the hash work just like value in FileMaker's Find mode. You can use any special
-	    # symbols (+==+, +...+, +>+, etc...).
-	    #
-			# Create a Filemaker 'omit' request by including an :omit key with a value of true.
-			# 
-			# 	myLayout.find :field1 => 'val1', :field2 => 'val2', :omit => true
-			# 
-			# Create multiple Filemaker find requests by passing an array of hashes to the #find method.
-			# 
-			# 	myLayout.find [{:field1 => 'bill', :field2 => 'admin'}, {:field3 => 'inactive', :omit => true}, ...]
-			# 
-			# If the value of a field in a find request is an array of strings, the string values will be logically OR'd in the query.
-			# 
-			# 	myLayout.find :fieldOne => ['bill','mike','bob'], :fieldTwo =>'staff'	    
-	    #
-	    # If you pass anything other than a hash or an array as the first parameter, it is converted to a string and
-	    # assumed to be FileMaker's internal id for a record (the recid).
-	    #
-	    #   myLayout.find 54321
-	    #
-	    def find(find_criteria, options = {})
-	    	#puts "layout.find-#{self.object_id}"
-	    	options.merge!({:field_mapping => field_mapping.invert}) if field_mapping
-				get_records(*Rfm::CompoundQuery.new(find_criteria, options))
-	    end
-	    
-	    # Access to raw -findquery command.
-	    def query(query_hash, options = {})
-	    	get_records('-findquery', query_hash, options)
-	    end
-	  
-	    # Updates the contents of the record whose internal +recid+ is specified. Send in a hash of new
-	    # data in the +values+ parameter. Returns a RecordSet containing the modified record. For example:
-	    #
-	    #   recid = myLayout.find({"First Name" => "Bill"})[0].record_id
-	    #   myLayout.edit(recid, {"First Name" => "Steve"})
-	    #
-	    # The above code would find the first record with _Bill_ in the First Name field and change the 
-	    # first name to _Steve_.
-	    def edit(recid, values, options = {})
-	      get_records('-edit', {'-recid' => recid}.merge(values), options)
-	      #get_records('-edit', {'-recid' => recid}.merge(expand_repeats(values)), options) # attempt to set repeating fields.
-	    end
-	    
-	    # Creates a new record in the table associated with this layout. Pass field data as a hash in the 
-	    # +values+ parameter. Returns the newly created record in a RecordSet. You can use the returned
-	    # record to, ie, discover the values in auto-enter fields (like serial numbers). 
-	    #
-	    # For example:
-	    #
-	    #   result = myLayout.create({"First Name" => "Jerry", "Last Name" => "Robin"})
-	    #   id = result[0]["ID"]
-	    #
-	    # The above code adds a new record with first name _Jerry_ and last name _Robin_. It then
-	    # puts the value from the ID field (a serial number) into a ruby variable called +id+.
-	    def create(values, options = {})
-	      get_records('-new', values, options)
-	    end
-	    
-	    # Deletes the record with the specified internal recid. Returns a ResultSet with the deleted record.
-	    #
-	    # For example:
-	    #
-	    #   recid = myLayout.find({"First Name" => "Bill"})[0].record_id
-	    #   myLayout.delete(recid)
-	    # 
-	    # The above code finds every record with _Bill_ in the First Name field, then deletes the first one.
-	    def delete(recid, options = {})
-	      get_records('-delete', {'-recid' => recid}, options)
-	      return nil
-	    end
-	    
-	    # Retrieves metadata only, with an empty resultset.
-	    def view(options = {})
-	    	get_records('-view', {}, options)
-	    end
-	    
-	    def get_records(action, extra_params = {}, options = {})
-	    	# TODO: The grammar stuff here won't work properly until you handle config between
-	    	# models/sublayouts/layout/server (Is this done now?).
-	    	grammar_option = state(options)[:grammar]
-	    	options.merge!(:grammar=>grammar_option) if grammar_option
-	      #include_portals = options[:include_portals] ? options.delete(:include_portals) : nil
-	      include_portals = !options[:ignore_portals]
-	      
-	      # Apply mapping from :field_mapping, to send correct params in URL.
-	      prms = params.merge(extra_params)
-	      map = field_mapping.invert
-	      options.merge!({:field_mapping => map}) if map
-	      # TODO: Make this part handle string AND symbol keys.
-	      #map.each{|k,v| prms[k]=prms.delete(v) if prms[v]}
-	      prms.dup.each_key{|k| prms[map[k.to_s]]=prms.delete(k) if map[k.to_s]}
-	      
-	      xml_response = server.connect(state[:account_name], state[:password], action, prms, options).body
-	      Rfm::Resultset.new(xml_response, self, include_portals)
-	    end
-	    
-	    def params
-	      {"-db" => db.name, "-lay" => self.name}
-	    end
-	    			
-			
-			# Intended to set each repeat individually but doesn't work with FM
-			def expand_repeats(hash)
-				hash.each do |key,val|
-					if val.kind_of? Array
-						val.each_with_index{|v, i| hash["#{key}(#{i+1})"] = v}
-						hash.delete(key)
-					end
-				end
-				hash
-			end
-			
-			# Intended to brute-force repeat setting but doesn't work with FM
-			def join_repeats(hash)
-				hash.each do |key,val|
-					if val.kind_of? Array
-						hash[key] = val.join('\x1D')
-					end
-				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
-		###
+    # Returns a ResultSet object containing _every record_ in the table associated with this layout.
+    def all(options = {})
+      get_records('-findall', {}, options)
+    end
     
+    # Returns a ResultSet containing a single random record from the table associated with this layout.
+    def any(options = {})
+      get_records('-findany', {}, options)
+    end
+  
+    # Finds a record. Typically you will pass in a hash of field names and values. For example:
+    #
+    #   myLayout.find({"First Name" => "Bill"})
+    #
+    # Values in the hash work just like value in FileMaker's Find mode. You can use any special
+    # symbols (+==+, +...+, +>+, etc...).
+    #
+		# Create a Filemaker 'omit' request by including an :omit key with a value of true.
+		# 
+		# 	myLayout.find :field1 => 'val1', :field2 => 'val2', :omit => true
+		# 
+		# Create multiple Filemaker find requests by passing an array of hashes to the #find method.
+		# 
+		# 	myLayout.find [{:field1 => 'bill', :field2 => 'admin'}, {:field3 => 'inactive', :omit => true}, ...]
+		# 
+		# If the value of a field in a find request is an array of strings, the string values will be logically OR'd in the query.
+		# 
+		# 	myLayout.find :fieldOne => ['bill','mike','bob'], :fieldTwo =>'staff'	    
+    #
+    # If you pass anything other than a hash or an array as the first parameter, it is converted to a string and
+    # assumed to be FileMaker's internal id for a record (the recid).
+    #
+    #   myLayout.find 54321
+    #
+    def find(find_criteria, options = {})
+    	#puts "layout.find-#{self.object_id}"
+    	options.merge!({:field_mapping => field_mapping.invert}) if field_mapping
+			get_records(*Rfm::CompoundQuery.new(find_criteria, options))
+    end
+    
+    # Access to raw -findquery command.
+    def query(query_hash, options = {})
+    	get_records('-findquery', query_hash, options)
+    end
+  
+    # Updates the contents of the record whose internal +recid+ is specified. Send in a hash of new
+    # data in the +values+ parameter. Returns a RecordSet containing the modified record. For example:
+    #
+    #   recid = myLayout.find({"First Name" => "Bill"})[0].record_id
+    #   myLayout.edit(recid, {"First Name" => "Steve"})
+    #
+    # The above code would find the first record with _Bill_ in the First Name field and change the 
+    # first name to _Steve_.
+    def edit(recid, values, options = {})
+      get_records('-edit', {'-recid' => recid}.merge(values), options)
+      #get_records('-edit', {'-recid' => recid}.merge(expand_repeats(values)), options) # attempt to set repeating fields.
+    end
     
-    def field_controls
-      load unless @loaded
-      @field_controls
+    # Creates a new record in the table associated with this layout. Pass field data as a hash in the 
+    # +values+ parameter. Returns the newly created record in a RecordSet. You can use the returned
+    # record to, ie, discover the values in auto-enter fields (like serial numbers). 
+    #
+    # For example:
+    #
+    #   result = myLayout.create({"First Name" => "Jerry", "Last Name" => "Robin"})
+    #   id = result[0]["ID"]
+    #
+    # The above code adds a new record with first name _Jerry_ and last name _Robin_. It then
+    # puts the value from the ID field (a serial number) into a ruby variable called +id+.
+    def create(values, options = {})
+      get_records('-new', values, options)
     end
     
-  	def field_names
-  		load unless @field_names
-  		@field_names
-  	end
-  	
-  	def field_names_no_load
-  		@field_names
-  	end
+    # Deletes the record with the specified internal recid. Returns a ResultSet with the deleted record.
+    #
+    # For example:
+    #
+    #   recid = myLayout.find({"First Name" => "Bill"})[0].record_id
+    #   myLayout.delete(recid)
+    # 
+    # The above code finds every record with _Bill_ in the First Name field, then deletes the first one.
+    def delete(recid, options = {})
+      get_records('-delete', {'-recid' => recid}, options)
+      return nil
+    end
     
-    def value_lists
-      load unless @loaded
-      @value_lists
+    # Retrieves metadata only, with an empty resultset.
+    def view(options = {})
+    	get_records('-view', {}, options)
     end
     
+    # Get the foundset_count only given criteria & options.
     def count(find_criteria, options={})
     	find(find_criteria, options.merge({:max_records => 0})).foundset_count
     end
     
-  	def total_count
-  		view.total_count
+    def get_records(action, extra_params = {}, options = {})
+    	# TODO: The grammar stuff here won't work properly until you handle config between
+    	# models/sublayouts/layout/server (Is this done now?).
+    	grammar_option = state(options)[:grammar]
+    	options.merge!(:grammar=>grammar_option) if grammar_option
+    	template = options.delete :template
+    	
+			# # TODO: Remove this code it is no longer used.
+			# #include_portals = options[:include_portals] ? options.delete(:include_portals) : nil
+			# include_portals = !options[:ignore_portals]
+      
+      # Apply mapping from :field_mapping, to send correct params in URL.
+      prms = params.merge(extra_params)
+      map = field_mapping.invert
+      options.merge!({:field_mapping => map}) if map && !map.empty?
+      # TODO: Make this part handle string AND symbol keys.
+      #map.each{|k,v| prms[k]=prms.delete(v) if prms[v]}
+      prms.dup.each_key{|k| prms[map[k.to_s]]=prms.delete(k) if map[k.to_s]}
+
+			#c = Connection.new(action, prms, options, state.merge(:parent=>self))
+			c = Connection.new(action, prms, options, self)
+			rslt = c.parse(template || :fmresultset, Rfm::Resultset.new(self, self))
+			capture_resultset_meta(rslt) unless @resultset_meta
+			rslt
+    end
+    
+    def params
+      {"-db" => state[:database], "-lay" => self.name}
+    end
+
+    def name; state[:layout].to_s; end
+	    
+	      
+    
+    
+    ###  Metadata from Layout  ###
+    
+    def meta
+    	@loaded ? @meta : load_layout
+    end
+    
+  	def field_names
+  		case
+  		when @loaded; meta.field_names
+  		when @resultset_meta; resultset_meta.field_names
+  		else meta.field_names
+  		end
   	end
   	
-  	def portal_meta
-  		@portal_meta ||= view.portal_meta
+  	def field_keys
+  		case
+  		when @loaded; @meta.field_keys
+  		when @resultset_meta; @resultset_meta.field_keys
+  		else meta.field_keys
+  		end
   	end
   	
-  	def portal_meta_no_load
-  		@portal_meta
-  	end
   	
+  	
+  		  
+    ###  Metadata from Resultset  ###
+    
+		def resultset_meta
+			@resultset_meta || view.meta
+		end
+		
+  	# Should always refresh
+  	def total_count
+  		view.total_count
+  	end
+		
+		def capture_resultset_meta(resultset)
+			(@resultset_meta = resultset.clone.replace([])) #unless @resultset_meta
+			@resultset_meta = resultset.meta
+		end
+		
   	def portal_names
-  		portal_meta.keys
+  		return 'UNDER-CONTSTRUCTION'
   	end
+
   	
-  	def table
-  		@table ||= view.table
-  	end
   	
-  	def table_no_load
-  		@table
-  	end
+  	
+  	###  Utility  ###
     
-    def load
-      @loaded = true
-      fmpxmllayout = db.server.load_layout(self)
-      doc = XmlParser.new(fmpxmllayout.body, :namespace=>false, :parser=>server.state[:parser])
-      
-      # check for errors
-      error = doc['FMPXMLLAYOUT']['ERRORCODE'].to_s.to_i
-      raise Rfm::Error::FileMakerError.getError(error) if error != 0
-      
-      # process valuelists
-      vlists = [doc['FMPXMLLAYOUT']['VALUELISTS']['VALUELIST']].flatten.compact
-      if !vlists.blank?    #root.elements['VALUELISTS'].size > 0
-        vlists.each {|valuelist|
-          name = valuelist['NAME']
-          @value_lists[name] = [valuelist['VALUE']].flatten.collect{|value|
-          	Rfm::Metadata::ValueListItem.new(value['__content__'], value['DISPLAY'], name)
-          } rescue []
-        }
-        @value_lists.freeze
-      end
-
-      # process field controls
-      [doc['FMPXMLLAYOUT']['LAYOUT']['FIELD']].flatten.compact.each {|field|
-        name = field_mapping[field['NAME']] || field['NAME']
-        style = field['STYLE']
-        type = style['TYPE']
-        value_list_name = style['VALUELIST']
-        value_list = @value_lists[value_list_name] if !value_list_name.blank?
-        field_control = Rfm::Metadata::FieldControl.new(name, type, value_list_name, value_list)
-        existing = @field_controls[name]
-        if existing
-          if existing.kind_of?(Array)
-            existing << field_control
-          else
-            @field_controls[name] = Array[existing, field_control]
-          end
-        else
-          @field_controls[name] = field_control
-        end
-      }
-      @field_names ||= @field_controls.collect{|k,v| v.name rescue v[0].name}
-      @field_controls.freeze
+    def load_layout
+    	@loaded = true # This is first so parsing call to 'meta' wont cause infinite loop.
+      connection = Connection.new('-view', {'-db' => state[:database], '-lay' => name}, {:grammar=>'FMPXMLLAYOUT'}, self)
+      rslt = connection.parse(:fmpxmllayout, self)
+      #puts ["LAYOUT#load_layout result", rslt.class].join(', ')
+			# @loaded = true
+			@meta
     end
     
 		def field_mapping
-			@field_mapping ||= load_field_mapping(get_config[:field_mapping])
+			@field_mapping ||= load_field_mapping(state[:field_mapping])
 		end
 		
 		def load_field_mapping(mapping={})
@@ -443,8 +393,31 @@ module Rfm
 			end
 			mapping
 		end
+		
+    # Creates new class with layout name.
+    def modelize
+    	@model ||= (
+	    	model_name = name.to_s.gsub(/\W|_/, ' ').title_case.gsub(/\s/,'')
+	    	#model_class = eval("::" + model_name + "= Class.new(Rfm::Base)")
+	    	model_class = Rfm.const_defined?(model_name) ? Rfm.const_get(model_name) : Rfm.const_set(model_name, Class.new(Rfm::Base))
+	    	model_class.class_exec(self) do |layout_obj|
+	    		@layout = layout_obj
+	    	end
+	  		model_class.config :parent=>'@layout'
+		    model_class
+	    )
+#     rescue StandardError, SyntaxError
+#     	puts "Error in layout#modelize: #{$!}"
+#     	nil
+  	end
+  	
+  	def models
+  		#subs.collect{|s| s.model}
+  		[@model]
+  	end
+				
     
-  	private :load, :get_records, :params
+  	private :load_layout, :get_records, :params
       
       
   end # Layout