ginjo-rfm 1.4.4 → 2.0.pre31

data/lib/rfm/metadata/script.rb

@@ -9,12 +9,14 @@ module Rfm
     #
     # If you want to _run_ a script, see the Layout object instead.
     class Script
-      def initialize(name, db)
+      def initialize(name, db_obj)
         @name = name
-        @db = db
+        self.db = db_obj
       end
       
+      meta_attr_accessor :db
       attr_reader :name
-    end
-  end
-end
+    end # Script
+    
+  end # Metadata
+end # Rfm

data/lib/rfm/record.rb

@@ -1,5 +1,4 @@
 module Rfm
-  
   # The Record object represents a single FileMaker record. You typically get them from ResultSet objects.
   # For example, you might use a Layout object to find some records:
   #
@@ -69,7 +68,14 @@ module Rfm
   #   }
   #
   # This code iterates through the rows of the _Orders_ portal.
-  # 
+  #
+  #	As a convenience, you can call a specific portal as a method on your record, if the table occurrence name does
+  # not have any characters that are prohibited in ruby method names, just as you can call a field with a method:
+	# 	
+	#   myRecord.orders.each {|portal_row|
+	#   	puts portal_row["Order Number"]
+	#   }
+	#   
   # =Field Types and Ruby Types
   #
   # RFM automatically converts data from FileMaker into a Ruby object with the most reasonable type possible. The 
@@ -100,41 +106,51 @@ module Rfm
   #   copy of the same record
   class Record < Rfm::CaseInsensitiveHash
     
+    attr_accessor :layout, :resultset
     attr_reader :record_id, :mod_id, :portals
+    def_delegators :resultset, :field_meta
+    def_delegators :layout, :db, :database, :server
 
-    def initialize(record, result, field_meta, layout, portal=nil)
-      @record_id = record['record-id']
-      @mod_id    = record['mod-id']
-      @mods      = {}
-      @layout    = layout
-      @portals ||= Rfm::CaseInsensitiveHash.new
+    def initialize(record, resultset_obj, field_meta, layout_obj, portal=nil)
 
-      relatedsets = !portal && result.instance_variable_get(:@include_portals) ? record.xpath('relatedset') : []
-      
-      record.xpath('field').each do |field|
+      @layout        = layout_obj
+      @resultset     = resultset_obj
+      @record_id     = record['record-id']
+      @mod_id        = record['mod-id']
+      @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|
+      	next unless field
         field_name = field['name']
         field_name.gsub!(Regexp.new(portal + '::'), '') if portal
         datum = []
         
-        field.xpath('data').each do |x| 
-          datum.push(field_meta[field_name].coerce(x.inner_text, result))
-        end
+        data = field['data']; data = data.is_a?(Hash) ? [data] : data
+        data.each do |x|
+        	next unless field_meta[field_name]
+          datum.push(field_meta[field_name].coerce(x['__content__'], resultset_obj))
+        end if data
       
         if datum.length == 1
-          self[field_name] = datum[0]
+          rfm_super[field_name] = datum[0]
         elsif datum.length == 0
-          self[field_name] = nil
+          rfm_super[field_name] = nil
         else
-          self[field_name] = datum
+          rfm_super[field_name] = datum
         end
       end
       
       unless relatedsets.empty?
         relatedsets.each do |relatedset|
+        	next if relatedset.blank?
           tablename, records = relatedset['table'], []
       
-          relatedset.xpath('record').each do |record|
-            records << self.class.new(record, result, result.portal_meta[tablename], layout, tablename)
+          relatedset['record'].rfm_force_array.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
@@ -144,9 +160,9 @@ module Rfm
       @loaded = true
     end
 
-    def self.build_records(records, result, field_meta, layout, portal=nil)
+    def self.build_records(records, resultset_obj, field_meta, layout_obj, portal=nil)
       records.each do |record|
-        result << self.new(record, result, field_meta, layout, portal)
+        resultset_obj << self.new(record, resultset_obj, field_meta, layout_obj, portal)
       end
     end
 
@@ -164,16 +180,15 @@ 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
       @mods.clear
     end
-    
 
     # Like Record::save, except it fails (and raises an error) if the underlying record in FileMaker was
     # 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
       @mods.clear
     end
     
@@ -190,43 +205,43 @@ 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 []=(name, value)
-    	name = name.to_s.downcase
-      return super unless @loaded
-      raise Rfm::ParameterError, 
-        "You attempted to modify a field that does not exist in the current Filemaker layout." unless self.key?(name)
-      @mods[name] = value
-      self.merge! @mods
-    end
-
-    alias :_old_hash_reader :[]
-    def [](value)
-      read_attribute(value)
-    end
+  	def [](key)
+  		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))
+  	end
 
     def respond_to?(symbol, include_private = false)
       return true if self.include?(symbol.to_s)
       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
+      super(key, value)
+    end
+    
+	  def field_names
+    	resultset.field_names rescue layout.field_names
+    end
 
-    private
 
-      def read_attribute(key)
-      	key_string = key.to_s.downcase
-        raise NoMethodError, 
-          "#{key_string} does not exists as a field in the current Filemaker layout." unless (!@layout or self.key?(key_string))   #!self.keys.grep(/#{key_string}/i).empty?
-        self._old_hash_reader(key).to_s.empty? ? nil : self._old_hash_reader(key) if self._old_hash_reader(key)
-      end
+  private
 
-      def method_missing (symbol, *attrs, &block)
-        method = symbol.to_s
-        return read_attribute(method) if self.key?(method)
-      
-        if method =~ /(=)$/ && self.key?($`)
-          return self[$`] = attrs.first
-        end
-        super
-      end
-    
-  end
-end
+  	def method_missing (symbol, *attrs, &block)
+  	  method = symbol.to_s
+  	  return self[method] if self.key?(method)
+  	  return @portals[method] if @portals and @portals.key?(method)
+
+  	  if method =~ /(=)$/
+  	    return self[$`] = attrs.first if self.key?($`)
+  	  end
+  	  super
+		end
+  	
+  end # Record
+end # Rfm

data/lib/rfm/resultset.rb

@@ -5,7 +5,7 @@
 # Author::    Geoff Coffey  (mailto:gwcoffey@gmail.com)
 # Copyright:: Copyright (c) 2007 Six Fried Rice, LLC and Mufaddal Khumri
 # License::   See MIT-LICENSE for details
-require 'nokogiri'
+
 require 'bigdecimal'
 require 'rfm/record'
 
@@ -40,7 +40,8 @@ module Rfm
     attr_reader :layout, :server
     attr_reader :field_meta, :portal_meta
     attr_reader :date_format, :time_format, :timestamp_format
-    attr_reader :total_count, :foundset_count
+    attr_reader :total_count, :foundset_count, :table
+    def_delegators :layout, :db, :database
     
     # Initializes a new ResultSet object. You will probably never do this your self (instead, use the Layout
     # object to get various ResultSet obejects).
@@ -64,62 +65,80 @@ module Rfm
     #   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, xml_response, layout, portals=nil)
-      @layout           = layout
-      @server           = server
+    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 
       
-      doc = Nokogiri.XML(remove_namespace(xml_response))
+      doc = XmlParser.new(xml_response, :namespace=>false, :parser=>server.state[:parser])
       
-      error = doc.xpath('/fmresultset/error').attribute('code').value.to_i
+      error = doc['fmresultset']['error']['code'].to_i
       check_for_errors(error, server.state[:raise_on_401])
 
-      datasource        = doc.xpath('/fmresultset/datasource')
-      meta              = doc.xpath('/fmresultset/metadata')
-      resultset         = doc.xpath('/fmresultset/resultset')
-
-      @date_format      = convert_date_time_format(datasource.attribute('date-format').value)
-      @time_format      = convert_date_time_format(datasource.attribute('time-format').value)
-      @timestamp_format = convert_date_time_format(datasource.attribute('timestamp-format').value)
+      datasource        = doc['fmresultset']['datasource']
+      meta              = doc['fmresultset']['metadata']
+      resultset         = doc['fmresultset']['resultset']
 
-      @foundset_count   = resultset.attribute('count').value.to_i
-      @total_count      = datasource.attribute('total-count').value.to_i
+      @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)
 
+      @foundset_count   = resultset['count'].to_s.to_i
+      @total_count      = datasource['total-count'].to_s.to_i
+      @table            = datasource['table']
+      
+      (layout.table = @table) if layout and layout.table_no_load.blank?
+      
       parse_fields(meta)
-      parse_portals(meta) if @include_portals
       
-      Rfm::Record.build_records(resultset.xpath('record'), self, @field_meta, @layout)
+      # This will always load portal meta, even if :include_portals was not specified.
+      # See Record for control of portal data loading.
+      parse_portals(meta)
       
+      return if resultset['record'].nil?
+      Rfm::Record.build_records(resultset['record'].rfm_force_array, self, @field_meta, @layout)
     end
+        
+    def field_names
+    	field_meta.collect{|k,v| v.name}
+  	end
+  	
+  	def portal_names
+  		portal_meta.keys
+  	end
+    
     
     private
-      def remove_namespace(xml)
-        xml.gsub('xmlns="http://www.filemaker.com/xml/fmresultset" version="1.0"', '')
-      end
     
       def check_for_errors(code, raise_401)
         raise Rfm::Error.getError(code) if code != 0 && (code != 401 || raise_401)
       end
     
       def parse_fields(meta)
-        meta.xpath('field-definition').each do |field|
+      	return if meta['field-definition'].blank?
+
+        meta['field-definition'].rfm_force_array.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)
-        meta.xpath('relatedset-definition').each do |relatedset|
-          table, fields = relatedset.attribute('table').value, {}
+      	return if meta['relatedset-definition'].blank?
+        meta['relatedset-definition'].rfm_force_array.each do |relatedset|
+        	next if relatedset.blank?
+          table, fields = relatedset['table'], {}
 
-          relatedset.xpath('field-definition').each do |field|
-            name = field.attribute('name').value.gsub(Regexp.new(table + '::'), '')
+          relatedset['field-definition'].rfm_force_array.each do |field|
+            name = field['name'].to_s.gsub(Regexp.new(table + '::'), '')
             fields[name] = Rfm::Metadata::Field.new(field)
           end
 
           @portal_meta[table] = fields
         end
+        (layout.portal_meta = @portal_meta) if layout and layout.portal_meta_no_load.blank?
       end
     
       def convert_date_time_format(fm_format)

data/lib/rfm/server.rb

@@ -107,13 +107,13 @@ module Rfm
   # * *name* is the name of this database
   # * *state* is a hash of all server options used to initialize this server
   class Server
-    #
+  
     # To create a Server object, you typically need at least a host name:
     # 
     #   myServer = Rfm::Server.new({:host => 'my.host.com'})
     #
-    # Several other options are supported:
-    #
+    # ===Several other options are supported
+    # 
     # * *host* the hostname of the Web Publishing Engine (WPE) server (defaults to 'localhost')
     #
     # * *port* the port number the WPE is listening no (defaults to 80 unless *ssl* +true+ which sets it to 443)
@@ -138,13 +138,13 @@ module Rfm
     #   ignores FileMaker's 401 error (no records found) and returns an empty record set instead; if you
     #   prefer a raised error when a find produces no errors, set this option to +true+
     #
-    # ===SSL Options (SSL AND CERTIFICATE VERIFICATION ARE ON BY DEFAULT):
-    #
+    # ===SSL Options (SSL AND CERTIFICATE VERIFICATION ARE ON BY DEFAULT)
+    # 
     # * *ssl* +false+ if you want to turn SSL (HTTPS) off when connecting to connect to FileMaker (default is +true+)
     #
-    # If you are using SSL and want to verify the certificate use the following options:
+    # If you are using SSL and want to verify the certificate, use the following options:
     #
-    # * *root_cert* +false+ if you do not want to verify your SSL session (default is +true+). 
+    # * *root_cert* +true+ is the default. If you do not want to verify your SSL session, set this to +false+. 
     #   You will want to turn this off if you are using a self signed certificate and do not have a certificate authority cert file.
     #   If you choose this option you will need to provide a cert *root_cert_name* and *root_cert_path* (if not in root directory).
     #
@@ -154,8 +154,8 @@ module Rfm
     #
     # * *root_cert_path* path to cert file. (defaults to '/' if no path given)
     #
-    # ===Configuration Examples:    
-    #
+    # ===Configuration Examples    
+    # 
     # Example to turn off SSL:
     # 
     #   myServer = Rfm::Server.new({
@@ -192,8 +192,9 @@ module Rfm
     #            :root_cert_name => 'example.pem'
     #            :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 == ''
+      
       @state = {
         :host => 'localhost',
         :port => 80,
@@ -205,17 +206,18 @@ module Rfm
         :password => '',
         :log_actions => false,
         :log_responses => false,
+        :log_parser => false,
         :warn_on_redirect => true,
         :raise_on_401 => false,
         :timeout => 60
       }.merge(options)
     
       @state.freeze
-    
+          
       @host_name = @state[:host]
       @scheme = @state[:ssl] ? "https" : "http"
       @port = @state[:ssl] && options[:port].nil? ? 443 : @state[:port]
-    
+      
       @db = Rfm::Factory::DbFactory.new(self)
     end
     
@@ -231,11 +233,13 @@ module Rfm
     # get no error at this point if the database you access doesn't exist. Instead, you'll
     # receive an error when you actually try to perform some action on a layout from this
     # database.
-    def [](dbname)
-      self.db[dbname]
-    end
+		#     def [](dbname, acnt=nil, pass=nil)
+		#       self.db[dbname, acnt, pass]
+		#     end
+    def_delegator :db, :[]
     
     attr_reader :db, :host_name, :port, :scheme, :state
+    alias_method :databases, :db
     
     # Performs a raw FileMaker action. You will generally not call this method directly, but it
     # is exposed in case you need to do something "under the hood."
@@ -272,12 +276,12 @@ module Rfm
     def load_layout(layout)
       post = {'-db' => layout.db.name, '-lay' => layout.name, '-view' => ''}
       resp = http_fetch(@host_name, @port, "/fmi/xml/FMPXMLLAYOUT.xml", layout.db.account_name, layout.db.password, post)
-      remove_namespace(resp.body)
+      #remove_namespace(resp.body)
     end
     
     # Removes namespace from fmpxmllayout, so xpath will work
   	def remove_namespace(xml)
-      xml.gsub('xmlns="http://www.filemaker.com/fmpxmllayout"', '')
+      xml.gsub(/xmlns=\"[^\"]*\"/, '')
     end
     
     private

data/lib/rfm/utilities/complex_query.rb

@@ -0,0 +1,64 @@
+module Rfm
+
+  module ComplexQuery # @private :nodoc:
+		# Methods for Rfm::Layout to build complex queries
+		# Perform RFM find using complex boolean logic (multiple value options for a single field)
+		# Mimics creation of multiple find requests for "or" logic
+		# Use: rlayout_object.query({'fieldOne'=>['val1','val2','val3'], 'fieldTwo'=>'someValue', ...})
+		def query(hash_or_recid, options = {})
+		  if hash_or_recid.kind_of? Hash
+		    get_records('-findquery', assemble_query(hash_or_recid), options)
+		  else
+		    get_records('-find', {'-recid' => hash_or_recid.to_s}, options)
+		  end
+		end
+
+		# Build ruby params to send to -query action via RFM
+		def assemble_query(query_hash)
+			key_values, query_map = build_key_values(query_hash)
+			key_values.merge("-query"=>query_translate(array_mix(query_map)))
+		end
+
+		# Build key-value definitions and query map  '-q1...'
+		def build_key_values(qh)
+			key_values = {}
+			query_map = []
+			counter = 0
+			qh.each_with_index do |ha,i|
+				ha[1] = ha[1].to_a
+				query_tag = []
+				ha[1].each do |v|
+					key_values["-q#{counter}"] = ha[0]
+					key_values["-q#{counter}.value"] = v
+					query_tag << "q#{counter}"
+					counter += 1
+				end
+				query_map << query_tag
+			end
+			return key_values, query_map
+		end
+
+		# Build query request logic for FMP requests  '-query...'
+		def array_mix(ary, line=[], rslt=[])
+			ary[0].to_a.each_with_index do |v,i|
+				array_mix(ary[1,ary.size], (line + [v]), rslt)
+				rslt << (line + [v]) if ary.size == 1
+			end
+			return rslt
+		end
+
+		# Translate query request logic to string
+		def query_translate(mixed_ary)
+			rslt = ""
+			sub = mixed_ary.collect {|a| "(#{a.join(',')})"}
+			sub.join(";")
+		end
+
+	end # ComplexQuery
+
+	#   class Layout
+	#   	require 'rfm/layout'
+	#     include ComplexQuery
+	#   end
+  
+end # Rfm