ginjo-rfm 3.0.9 → 3.0.10

data/lib/rfm/database.rb

@@ -58,8 +58,8 @@ 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
-  
+    include Config
+
     # Initialize a database object. You never really need to do this. Instead, just do this:
     # 
     #   myServer = Rfm::Server.new(...)
@@ -67,12 +67,12 @@ 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
-			config(*args)
+      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_accessor :server
     attr_reader :layouts, :scripts
     # Not sure if these writers are ever used
@@ -80,25 +80,39 @@ module Rfm
     # 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 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 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
+      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
-    
+    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:
     #
@@ -111,10 +125,10 @@ module Rfm
     # returned is created on the fly and assumed to refer to a valid layout, but you will
     # get no error at this point if the layout you specify doesn't exist. Instead, you'll
     # receive an error when you actually try to perform some action it.
-		#     def [](layout_name)
-		#       self.layout[layout_name]
-		#     end
+    #     def [](layout_name)
+    #       self.layout[layout_name]
+    #     end
     def_delegators :layouts, :[], :modelize, :models # modelize & models acquired from Rfm::Base
 
   end
-end
+end

data/lib/rfm/error.rb

@@ -1,38 +1,38 @@
 module Rfm
-  
+
   # Error is the base for the error hierarchy representing errors returned by Filemaker.
-  # 
+  #
   # One could raise a FileMakerError by doing:
   #   raise Rfm::Error.getError(102)
   #
   # It also takes an optional argument to give a more discriptive error message:
   #   err = Rfm::Error.getError(102, 'add description with more detail here')
-  # 
+  #
   # The above code would return a FieldMissing instance. Your could use this instance to raise that appropriate
   # exception:
-  # 
-  #   raise err 
-  # 
+  #
+  #   raise err
+  #
   # You could access the specific error code by accessing:
-  #   
+  #
   #   err.code
   module Error
-    
+
     class RfmError < StandardError #:nodoc:
       attr_reader :code
-      
+
       def initialize(code, message=nil)
         @code = code
         super(message)
       end
     end
 
-    class UnknownError < RfmError 
+    class UnknownError < RfmError
     end
-    
+
     class SystemError  < RfmError
     end
-    
+
     class MissingError < RfmError
     end
 
@@ -42,10 +42,10 @@ module Rfm
     class FieldMissingError  < MissingError #:nodoc:
     end
 
-    class ScriptMissingError < MissingError #:nodoc: 
+    class ScriptMissingError < MissingError #:nodoc:
     end
 
-    class LayoutMissingError < MissingError #:nodoc: 
+    class LayoutMissingError < MissingError #:nodoc:
     end
 
     class TableMissingError  < MissingError #:nodoc:
@@ -82,7 +82,7 @@ module Rfm
     end
 
     class ValidationError < RfmError #:nodoc:
-    end 
+    end
 
     class DateValidationError < ValidationError #:nodoc:
     end
@@ -90,7 +90,7 @@ module Rfm
     class TimeValidationError < ValidationError #:nodoc:
     end
 
-    class NumberValidationError < ValidationError #:nodoc: 
+    class NumberValidationError < ValidationError #:nodoc:
     end
 
     class RangeValidationError < ValidationError #:nodoc:
@@ -115,11 +115,11 @@ module Rfm
     end
 
     class FileError < RfmError #:nodoc:
-    end 
+    end
 
     class UnableToOpenFileError < FileError #:nodoc:
     end
-    
+
     extend self
     # This method returns the appropriate FileMaker object depending on the error code passed to it. It
     # also accepts an optional message.
@@ -129,15 +129,15 @@ module Rfm
       error   = klass.new(code, message)
       error
     end
-    
+
     def build_message(klass, code, message=nil) #:nodoc:
       msg =  ": #{message}"
       msg << " " unless message.nil?
       msg << "(FileMaker Error ##{code})"
-      
+
       "#{klass.to_s.gsub(/Rfm::Error::/, '')} occurred#{msg}"
     end
-    
+
     def find_by_code(code) #:nodoc:
       case code
       when 0..99 then SystemError
@@ -159,8 +159,8 @@ module Rfm
         elsif code == 306; RecordModIdDoesNotMatchError
         else; ConcurrencyError; end
       when 400..499
-       if code == 401; NoRecordsFoundError
-       else; GeneralError; end
+        if code == 401; NoRecordsFoundError
+        else; GeneralError; end
       when 500..599
         if code == 500; DateValidationError
         elsif code == 501; TimeValidationError
@@ -182,5 +182,5 @@ module Rfm
       end
     end
   end
-  
-end
+
+end

data/lib/rfm/layout.rb

@@ -1,4 +1,5 @@
 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
@@ -118,45 +119,47 @@ module Rfm
   # * +value_lists+ is a hash of arrays. The keys are value list names, and the values in the hash
   #   are arrays containing the actual value list items. +value_lists+ will include every value
   #   list that is attached to any field on the layout
-  
+
   class Layout
-	  include Config
+    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
+
+    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
-	  
-	  
-		    
+    # 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:
     # 
     #   myServer = Rfm::Server.new(...)
@@ -170,38 +173,39 @@ module Rfm
     #
     #   myServer = Rfm::Server.new(...)
     #   myLayout = myServer["Customers"]["Details"]
+
     def initialize(*args) #name, db_obj
-#     	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 == ''         
+      # 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
       @meta = Metadata::LayoutMeta.new(self)
       self
     end
 
     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
+      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
-    
+
     alias_method :db_orig, :db
-  	def db
-  		db_orig || (self.db = Rfm::Database.new(state[:database], state[:account_name], state[:password], self))
-  	end
-    
+    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"})
@@ -209,17 +213,17 @@ module Rfm
     # 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'	    
+    # 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).
@@ -227,16 +231,16 @@ module Rfm
     #   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))
+      #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)
+      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:
     #
@@ -249,7 +253,7 @@ module Rfm
       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). 
@@ -264,7 +268,7 @@ module Rfm
     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:
@@ -277,171 +281,189 @@ module Rfm
       get_records('-delete', {'-recid' => recid}, options)
       return nil
     end
-    
+
     # Retrieves metadata only, with an empty resultset.
     def view(options = {})
-    	get_records('-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
+      find(find_criteria, options.merge({:max_records => 0})).foundset_count
     end
-    
+
     def get_records(action, extra_params = {}, options = {})
-    	# TODO: See auto-grammar bypbass in connection.rb.
-    	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]
-      
+      # TODO: See auto-grammar bypbass in connection.rb.
+      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. (isn't this already done?)
       #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]}
       prms.dup.each_key do |k|
-      	new_key = map[k.to_s] || k
-      	if prms[new_key].is_a? Array
-					prms[new_key].each_with_index do |v, i|
-	      		prms["#{new_key}(#{i+1})"]=v
-      		end
-      		prms.delete new_key
-      	else
-	      	prms[new_key]=prms.delete(k) if new_key != k
-      	end
-      	#puts "PRMS: #{new_key} #{prms[new_key].class} #{prms[new_key]}"
+        new_key = map[k.to_s] || k
+        if prms[new_key].is_a? Array
+          prms[new_key].each_with_index do |v, i|
+            prms["#{new_key}(#{i+1})"]=v
+          end
+          prms.delete new_key
+        else
+          prms[new_key]=prms.delete(k) if new_key != k
+        end
+        #puts "PRMS: #{new_key} #{prms[new_key].class} #{prms[new_key]}"
       end
-			
-			#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))
-			rslt = c.parse(template, Rfm::Resultset.new(self, self))
-			capture_resultset_meta(rslt) unless @resultset_meta
-			rslt
+
+      #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))
+      rslt = c.parse(template, Rfm::Resultset.new(self, self))
+      capture_resultset_meta(rslt) unless resultset_meta_valid? #(@resultset_meta && @resultset_meta.error != '401')
+      rslt
     end
-    
+
     def params
       {"-db" => state[:database], "-lay" => self.name}
     end
 
-    def name; state[:layout].to_s; end
-	    
-	      
-    
-    
+    def name
+      state[:layout].to_s
+    end
+
+
     ###  Metadata from Layout  ###
-    
+
     def meta
-    	@loaded ? @meta : load_layout
+      @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 field_keys
-  		case
-  		when @loaded; @meta.field_keys
-  		when @resultset_meta; @resultset_meta.field_keys
-  		else meta.field_keys
-  		end
-  	end
-  	
-  	
-  	
-  		  
+
+    def field_names
+      case
+      when @loaded
+        meta.field_names
+      when @resultset_meta
+        resultset_meta.field_names
+      else meta.field_names
+      end
+    end
+
+    def field_names
+      # case
+      # when @loaded; meta.field_names
+      # when @resultset_meta; resultset_meta.field_names
+      # else meta.field_names
+      # end
+      meta.field_names
+    end
+
+    def field_keys
+      # case
+      # when @loaded; @meta.field_keys
+      # when @resultset_meta; @resultset_meta.field_keys
+      # else meta.field_keys
+      # end
+      meta.field_keys
+    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
-  		return 'UNDER-CONTSTRUCTION'
-  	end
-
-  	
-  	
-  	
-  	###  Utility  ###
-    
+
+    def resultset_meta
+      #@resultset_meta || view.meta
+      resultset_meta_valid? ? @resultset_meta : view.meta
+    end
+
+    def resultset_meta_valid?
+      if @resultset_meta && @resultset_meta.error != '401'
+        true
+      end
+    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
+      return 'UNDER-CONTSTRUCTION'
+    end
+
+
+
+
+    ###  Utility  ###
+
     def load_layout
-    	#@loaded = true # This is first so parsing call to 'meta' wont cause infinite loop,
-    	# but I changed parsing template to refer directly to inst var instead of accessor method.
+      #@loaded = true # This is first so parsing call to 'meta' wont cause infinite loop,
+      # but I changed parsing template to refer directly to inst var instead of accessor method.
       connection = Connection.new('-view', {'-db' => state[:database], '-lay' => name}, {:grammar=>'FMPXMLLAYOUT'}, self)
       begin
-	      connection.parse(:fmpxmllayout, self)
-	      @loaded = true
-	    rescue
-	    	@meta.clear
-	    	raise $!
-	    end
-			@meta
+        connection.parse(:fmpxmllayout, self)
+        @loaded = true
+      rescue
+        @meta.clear
+        raise $!
+      end
+      @meta
     end
-    
+
     def check_for_errors(code=@meta['error'].to_i, raise_401=state[:raise_401])
-    	#puts ["\nRESULTSET#check_for_errors", code, raise_401]
+      #puts ["\nRESULTSET#check_for_errors", code, raise_401]
       raise Rfm::Error.getError(code) if code != 0 && (code != 401 || raise_401)
     end
-    
-		def field_mapping
-			@field_mapping ||= load_field_mapping(state[:field_mapping])
-		end
-		
-		def load_field_mapping(mapping={})
-			mapping = (mapping || {}).to_cih
-			def mapping.invert
-				super.to_cih
-			end
-			mapping
-		end
-		
+
+    def field_mapping
+      @field_mapping ||= load_field_mapping(state[:field_mapping])
+    end
+
+    def load_field_mapping(mapping={})
+      mapping = (mapping || {}).to_cih
+      def mapping.invert
+        super.to_cih
+      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_layout, :get_records, :params, :check_for_errors
-      
-      
+      @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_layout, :get_records, :params, :check_for_errors
+
+
   end # Layout
-end # Rfm
+end # Rfm