ginjo-rfm 2.0.pre31 → 2.0.0

data/lib/rfm.rb

@@ -5,10 +5,9 @@ end
 
 require 'thread' # some versions of ActiveSupport will raise error about Mutex unless 'thread' is loaded.
 require 'active_support'
-# ActiveSupport appears to load these automatcially
-	#require 'active_support/core_ext/object/blank'
-	#require 'active_support/ordered_hash'
-	require 'active_support/version'
+require 'active_support/core_ext/object/blank'
+require 'active_support/ordered_hash'
+require 'active_support/version'
 require 'rfm/utilities/core_ext'
 require 'rfm/utilities/case_insensitive_hash'
 #require 'rfm/utilities/config'
@@ -29,9 +28,9 @@ module Rfm
   autoload :Record,       'rfm/record'
   autoload :Base,         'rfm/base'
   autoload :XmlParser,    'rfm/utilities/xml_parser'
-  autoload :ComplexQuery, 'rfm/utilities/complex_query'
   autoload :Config,       'rfm/utilities/config'
   autoload :Factory,      'rfm/utilities/factory'
+  autoload :CompoundQuery,'rfm/utilities/compound_query'
   autoload :VERSION,      'rfm/version'
 
 	module Metadata

data/lib/rfm/VERSION

@@ -1 +1 @@
-2.0.pre31
+2.0.0

data/lib/rfm/base.rb

@@ -31,12 +31,6 @@ module Rfm
 	#   @person.save
 	# 
 	# 
-	#
-	#
-	# :nodoc: TODO: make sure all methods return something (a record?) if successful, otherwise nil or error
-	# :nodoc: TODO: move rfm methods & patches from fetch_mail_with_ruby to this file
-	#
-	# TODO: Are these really needed here?
 	require 'rfm/database'
 	require 'rfm/layout'
 	require 'rfm/record'
@@ -169,7 +163,7 @@ module Rfm
       include ActiveModel::Validations
       include ActiveModel::Serialization
       extend ActiveModel::Callbacks
-      define_model_callbacks(:create, :update, :destroy)
+      define_model_callbacks(:create, :update, :destroy, :validate)
     rescue LoadError, StandardError
     	def run_callbacks(*args)
     		yield
@@ -199,7 +193,7 @@ module Rfm
 		
 	    # Access layout functions from base model
 	  	def_delegators :layout, :db, :server, :field_controls, :field_names, :value_lists, :total_count,
-	  									:query, :all, :delete, :portal_meta, :portal_names, :database, :table
+	  									:query, :all, :delete, :portal_meta, :portal_names, :database, :table, :count
 
 			def inherited(model)
 				(Rfm::Factory.models << model).uniq unless Rfm::Factory.models.include? model
@@ -230,9 +224,9 @@ module Rfm
 	  	end
 		  			
 			# Just like Layout#find, but searching by record_id will return a record, not a resultset.
-	  	def find(*args)
-	  	  r = layout.find(*args)
-	  	  if args[0].class != Hash and r.size == 1
+	  	def find(find_criteria, options={})
+	  	  r = layout.find(find_criteria, options={})
+	  	  if ![Hash,Array].include?(find_criteria.class) and r.size == 1
 	  	    r[0]
 		    else
 		      r

data/lib/rfm/database.rb

@@ -66,7 +66,7 @@ module Rfm
     #
     # 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.") if name.to_s == ''
+    	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 ""

data/lib/rfm/layout.rb

@@ -119,9 +119,7 @@ module Rfm
   #   list that is attached to any field on the layout
   
   class Layout
-		
-  	include ComplexQuery
-    
+		    
     # Initialize a layout object. You never really need to do this. Instead, just do this:
     # 
     #   myServer = Rfm::Server.new(...)
@@ -136,7 +134,7 @@ 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.") if name.to_s == ''
+    	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
       
@@ -156,6 +154,10 @@ module Rfm
     
     # 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.
+    # 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.
     module LayoutModule
     
 	    # Returns a ResultSet object containing _every record_ in the table associated with this layout.
@@ -175,14 +177,30 @@ module Rfm
 	    # Values in the hash work just like value in FileMaker's Find mode. You can use any special
 	    # symbols (+==+, +...+, +>+, etc...).
 	    #
-	    # If you pass anything other than a hash as the first parameter, it is converted to a string and
+			# 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).
-	    def find(hash_or_recid, options = {})
-	      if hash_or_recid.kind_of? Hash
-	        get_records('-find', hash_or_recid, options)
-	      else
-	        get_records('-find', {'-recid' => hash_or_recid.to_s}, options)
-	      end
+	    #
+	    #   myLayout.find 54321
+	    #
+	    def find(find_criteria, options = {})
+				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
@@ -195,6 +213,7 @@ module Rfm
 	    # 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 
@@ -225,6 +244,11 @@ module Rfm
 	      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 = {})
 	      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
@@ -234,6 +258,28 @@ module Rfm
 	    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
 	    
 	  end # LayoutModule
 	  include LayoutModule
@@ -258,12 +304,16 @@ module Rfm
       @value_lists
     end
     
+    def count(find_criteria, options={})
+    	find(find_criteria, options.merge({:max_records => 0})).foundset_count
+    end
+    
   	def total_count
-  		any.total_count
+  		view.total_count
   	end
   	
   	def portal_meta
-  		@portal_meta ||= any.portal_meta
+  		@portal_meta ||= view.portal_meta
   	end
   	
   	def portal_meta_no_load
@@ -275,7 +325,7 @@ module Rfm
   	end
   	
   	def table
-  		@table ||= any.table
+  		@table ||= view.table
   	end
   	
   	def table_no_load

data/lib/rfm/record.rb

@@ -57,6 +57,8 @@ module Rfm
   # In the above example, the Price field is a repeating field. The code puts the first repetition in a variable called 
   # +val1+ and the second in a variable called +val2+.
   #
+  # It is not currently possible to create or edit a record's repeating fields beyond the first repitition, using Rfm.
+  #
   # =Accessing Portals
   #
   # If the ResultSet includes portals (because the layout it comes from has portals on it) you can access them
@@ -108,7 +110,7 @@ module Rfm
     
     attr_accessor :layout, :resultset
     attr_reader :record_id, :mod_id, :portals
-    def_delegators :resultset, :field_meta
+    def_delegators :resultset, :field_meta, :portal_names
     def_delegators :layout, :db, :database, :server
 
     def initialize(record, resultset_obj, field_meta, layout_obj, portal=nil)

data/lib/rfm/server.rb

@@ -193,7 +193,7 @@ module Rfm
     #            :root_cert_path => '/usr/cert_file/'
     #            })
     def initialize(options)
-    	raise Rfm::Error::RfmError.new(0, "New instance of Rfm::Server has no host name.") if options[:host].to_s == ''
+    	raise Rfm::Error::RfmError.new(0, "New instance of Rfm::Server has no host name. Attempted name '#{options[:host]}'.") if options[:host].to_s == ''
       
       @state = {
         :host => 'localhost',
@@ -290,8 +290,10 @@ module Rfm
         raise Rfm::CommunicationError.new("While trying to reach the Web Publishing Engine, RFM was redirected too many times.") if limit == 0
     
         if @state[:log_actions] == true
-          qs = post_data.collect{|key,val| "#{CGI::escape(key.to_s)}=#{CGI::escape(val.to_s)}"}.join("&")
-          warn "#{@scheme}://#{@host_name}:#{@port}#{path}?#{qs}"
+          #qs = post_data.collect{|key,val| "#{CGI::escape(key.to_s)}=#{CGI::escape(val.to_s)}"}.join("&")
+          qs_unescaped = post_data.collect{|key,val| "#{key.to_s}=#{val.to_s}"}.join("&")
+          #warn "#{@scheme}://#{@host_name}:#{@port}#{path}?#{qs}"
+          warn "#{@scheme}://#{@host_name}:#{@port}#{path}?#{qs_unescaped}"
         end
     
         request = Net::HTTP::Post.new(path)

data/lib/rfm/utilities/compound_query.rb

@@ -0,0 +1,113 @@
+module Rfm
+
+
+	# Class to build complex FMP queries
+	# Perform Filemaker find using complex boolean logic (multiple value options for a single field)
+	# Or create multiple find requests.
+	# Also allow find requests to be :omit
+  class CompoundQuery < Array # @private :nodoc:
+  
+  	attr_accessor :original_input, :query_type, :key_values, :key_arrays, :key_map, :key_map_string, :key_counter
+  	
+  	def self.build_test
+  		new([{:field1=>['val1a','val1b','val1c'], :field2=>'val2'},{:omit=>true, :field3=>'val3', :field4=>'val4'}, {:omit=>true, :field5=>['val5a','val5b'], :field6=>['val6a','val6b']}], {})
+  	end
+  	
+  	# New CompoundQuery objects expect one of 3 data types:
+  	# * string/integer representing FMP internal record id
+  	# * hash of find-criteria
+  	# * array of find-criteria hashes
+  	#
+  	# Returns self as ['-fmpaction', {:hash=>'of', :key=>'values'}, {:options=>'hash'}]
+  	def initialize(query, options={})
+  		@options = options
+  		@original_input = query
+			@key_values = {}
+			@key_arrays = []
+			@key_map = []
+			@key_map_string = ''
+			@key_counter = 0
+
+  		case query
+			when Hash
+				if query.detect{|k,v| v.kind_of? Array or k == :omit}
+					@query_type = 'mixed'
+				else
+					@query_type = 'standard'
+				end
+			when Array
+				@query_type = 'compound'
+			else
+				@query_type = 'recid'
+			end
+			build_query
+  	end
+
+		# Master control method to build output
+  	def build_query(input=original_input)
+  		case @query_type
+	  	when 'mixed', 'compound'
+	  		input.rfm_force_array.each do |hash|
+	  			build_key_map(build_key_values(hash))
+	  		end
+	  		translate_key_map
+	  		self.push '-findquery'
+	  		self.push @key_values.merge('-query'=>@key_map_string)
+	  	when 'standard'
+	  		self.push '-find'
+	  		self.push @original_input
+	  	when 'recid'
+	  		self.push '-find'
+	  		self.push '-recid' => @original_input.to_s
+	  	end
+	  	self.push @options
+	  	self
+  	end
+
+
+		# Build key-value definitions and query map  '-q1...'
+		# Converts query_hash to fmresultset uri format for -findquery query type.
+		def build_key_values(input_hash)
+			input_hash = input_hash.clone
+			keyarray = []
+			omit = input_hash.delete(:omit)
+			input_hash.each do |key,val|
+				query_tag = []
+				val = val.rfm_force_array
+				val.each do |v|
+					@key_values["-q#{key_counter}"] = key
+					@key_values["-q#{key_counter}.value"] = v
+					query_tag << "q#{key_counter}"
+					@key_counter += 1
+				end
+				keyarray << query_tag
+			end
+			(keyarray << :omit) if omit
+			@key_arrays << keyarray
+			keyarray
+		end
+
+		
+		# Input array of arrays.
+		# Transform single key_array into key_map (array of requests)
+		# Creates all combinations of sub-arrays where each combination contains one element of each subarray.
+		def build_key_map(key_array)
+			key_array = key_array.clone
+			omit = key_array.delete(:omit)
+			len = key_array.length
+			flat = key_array.flatten
+			rslt = flat.combination(len).select{|c| key_array.all?{|a| (a & c).size > 0}}.each{|c| c.unshift(:omit) if omit}
+			@key_map.concat rslt
+		end
+
+		# Translate @key_map to FMP -query string
+		def translate_key_map(keymap=key_map)
+			keymap = keymap.clone
+			inner = keymap.collect {|a| "#{'!' if a.delete(:omit)}(#{a.join(',')})"}
+			outter = inner.join(';')
+			@key_map_string << outter
+		end
+
+  end # CompoundQuery
+
+end # Rfm

data/lib/rfm/utilities/config.rb

@@ -5,18 +5,35 @@ module Rfm
 	# The subsets can be any grouping of defined config parameters, as a hash.
 	# See CONFIG_KEYS for defined config parameters.
 	#
-	# All filters are honored, unless filters are included in calls to get_config,
-	# in which case only the immediately specified filters will be used.
-	#
-	# Do not put a :use=>:group filter in a subset (maybe future feature?).
-	# Do not put a :use=>:group filter in the top-level global parameters.
-	# Do not put subsets in non-top-level configs. (maybe future feature?)
-	#
   module Config
-  	CONFIG_KEYS = %w(parser host port account_name password database layout ssl root_cert root_cert_name root_cert_path warn_on_redirect raise_on_401 timeout log_actions log_responses log_parser use parent)
+  	require 'yaml'
+  	
+  	CONFIG_KEYS = %w(
+			file_name
+			file_path
+			parser
+			host
+			port
+			account_name
+			password
+			database
+			layout
+			ssl
+			root_cert
+			root_cert_name
+			root_cert_path
+			warn_on_redirect
+			raise_on_401
+			timeout
+			log_actions
+			log_responses
+			log_parser
+			use
+			parent
+		)
 
     extend self
-    @config = {}
+    @config = {}		
 	  	  
 	  # Set @config with args & options hash.
 	  # Args should be symbols representing configuration groups,
@@ -73,6 +90,22 @@ module Rfm
   	end
   		  
 	protected
+	
+		# Get or load a config file as the top-level config (above RFM_CONFIG constant).
+		# Default file name is rfm.yml.
+		# Default paths are '' and 'config/'.
+		# File name & paths can be set in RFM_CONFIG and Rfm.config.
+		# Change file name with :file_name => 'something.else'
+		# Change file paths with :file_path => ['array/of/', 'file/paths/']
+		def get_config_file
+			@@config_file_data ||= (
+				config_file_name = @config[:file_name] || (RFM_CONFIG[:file_name] rescue nil) || 'rfm.yml'
+				config_file_paths = [''] | (@config[:file_path] || (RFM_CONFIG[:file_path] rescue nil) || %w( config/ ))
+				config_file_paths.collect do |f|
+					(YAML.load_file("#{f}#{config_file_name}") rescue {})
+				end.inject({}){|h,a| h.merge(a)}
+			) || {}
+		end
 	  
 	  
 		# Merge args into @config, as :use=>[arg1, arg2, ...]
@@ -91,21 +124,31 @@ module Rfm
       remote = if (self != Rfm::Config) 
       	eval(@config[:parent] || 'Rfm::Config').config_merge_with_parent rescue {}
       else
-      	(defined?(RFM_CONFIG) and RFM_CONFIG.is_a?(Hash)) ? RFM_CONFIG : {}
+      	get_config_file.merge((defined?(RFM_CONFIG) and RFM_CONFIG.is_a?(Hash)) ? RFM_CONFIG : {})
       end
       
       use = (remote[:use].rfm_force_array | @config[:use].rfm_force_array).compact
 			remote.merge(@config).merge(:use=>use)
-    end	  
-
-		# Given config hash, return filtered. Filters should be symbols.
+    end
+     
+		# This version uses either/or method input filters OR compiled config :use=>filters.
+		# Given config hash, return filtered subgroup settings. Filters should be symbols.
+		# 		def config_filter(conf, filters=nil)
+		# 			filters ||= conf[:use].rfm_force_array if !conf[:use].blank?
+		# 			filters.each{|f| next unless conf[f]; conf.merge!(conf[f] || {})} if !filters.blank?
+		# 			conf.reject!{|k,v| !CONFIG_KEYS.include?(k.to_s) or v.to_s == '' }
+		# 			conf
+		# 		end
+		#
+		# This version combines both method input filters AND :use=>filters
 		def config_filter(conf, filters=nil)
-			filters ||= conf[:use].rfm_force_array if !conf[:use].blank?
+			filters = conf[:use] = (conf[:use].rfm_force_array | filters.rfm_force_array).compact
 			filters.each{|f| next unless conf[f]; conf.merge!(conf[f] || {})} if !filters.blank?
-			conf.reject!{|k,v| !CONFIG_KEYS.include?(k.to_s) or v.to_s == '' }
+			conf.reject!{|k,v| !CONFIG_KEYS.include?(k.to_s) or [{},[],''].include?(v) }
 			conf
 		end
-    
+		
+		    
     # This loads RFM_CONFIG into @config. It is not necessary,
     # as get_config will merge all configuration into RFM_CONFIG at runtime.
     #config RFM_CONFIG if defined? RFM_CONFIG