ginjo-rfm 2.1.7 → 3.0.0

data/lib/rfm/utilities/connection.rb

@@ -0,0 +1,209 @@
+# Connection object takes over the communication functionality that was previously in Rfm::Server.
+# TODO: Clean up the way :grammar is sent in to the initializing method.
+#       Currently, the actual connection instance config doesn't get set with the correct grammar,
+#       even if the http_fetch is using the correct grammar.
+
+require 'net/https'
+require 'cgi'
+module Rfm
+# These have been moved to rfm.rb.
+# 	SaxParser.default_class = CaseInsensitiveHash
+# 	SaxParser.template_prefix = File.join(File.dirname(__FILE__), './sax/')
+# 	SaxParser.templates.merge!({
+# 		:fmpxmllayout => 'fmpxmllayout.yml',
+# 		:fmresultset => 'fmresultset.yml',
+# 		:fmpxmlresult => 'fmpxmlresult.yml',
+# 		:none => nil
+# 	})
+	
+  class Connection
+  	include Config  	
+  
+		def initialize(action, params, request_options={},  *args)
+    	config *args
+      
+      # Action sent to FMS
+      @action = action
+      # Query params sent to FMS
+      @params = params
+      # Additional options sent to FMS
+      @request_options = request_options
+      
+      @defaults = {
+        :host => 'localhost',
+        #:port => 80,
+        :ssl => true,
+        :root_cert => true,
+        :root_cert_name => '',
+        :root_cert_path => '/',
+        :account_name => '',
+        :password => '',
+        :log_actions => false,
+        :log_responses => false,
+        :log_parser => false,
+        :warn_on_redirect => true,
+        :raise_on_401 => false,
+        :timeout => 60,
+        :ignore_bad_data => false,
+        :grammar => 'fmresultset'
+      }   #.merge(options)
+	
+    end
+
+    def state(*args)
+    	@defaults.merge(super(*args))
+    end
+    
+	  def host_name; state[:host]; end
+	  def scheme; state[:ssl] ? "https" : "http"; end
+	  def port; state[:ssl] && state[:port].nil? ? 443 : state[:port]; end
+
+    def connect(action=@action, params=@params, request_options = @request_options, account_name=state[:account_name], password=state[:password])
+    	grammar_option = request_options.delete(:grammar)
+      post = params.merge(expand_options(request_options)).merge({action => ''})
+      grammar = select_grammar(post, :grammar=>grammar_option)
+      http_fetch(host_name, port, "/fmi/xml/#{grammar}.xml", account_name, password, post)
+    end
+
+    def select_grammar(post, options={})
+			grammar = state(options)[:grammar] || 'fmresultset'
+			if grammar.to_s.downcase == 'auto'
+				post.keys.find(){|k| %w(-find -findall -dbnames -layoutnames -scriptnames).include? k.to_s} ? "FMPXMLRESULT" : "fmresultset"   
+    	else
+    		grammar
+    	end
+    end
+    
+    def parse(template=nil, initial_object=nil, parser=nil, options={})
+    	(template =  'fmresultset.yml') unless template
+    	#(template = File.join(File.dirname(__FILE__), '../sax/', template)) if template.is_a? String
+    	Rfm::SaxParser.parse(connect.body, template, initial_object, parser, state(*options)).result
+    end
+
+
+
+
+  private
+  
+    def http_fetch(host_name, port, path, account_name, password, post_data, limit=10)
+      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("&")
+        qs_unescaped = post_data.collect{|key,val| "#{key.to_s}=#{val.to_s}"}.join("&")
+        #warn "#{@scheme}://#{@host_name}:#{@port}#{path}?#{qs}"
+        log.info "#{scheme}://#{host_name}:#{port}#{path}?#{qs_unescaped}"
+      end
+  
+      request = Net::HTTP::Post.new(path)
+      request.basic_auth(account_name, password)
+      request.set_form_data(post_data)
+  
+      connection = Net::HTTP.new(host_name, port)
+      #ADDED LONG TIMEOUT TIMOTHY TING 05/12/2011
+      connection.open_timeout = connection.read_timeout = state[:timeout]
+      if state[:ssl]
+        connection.use_ssl = true
+        if state[:root_cert]
+          connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          connection.ca_file = File.join(state[:root_cert_path], state[:root_cert_name])
+        else
+          connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+      end
+  
+      response = connection.start { |http| http.request(request) }
+      if state[:log_responses] == true
+        response.to_hash.each { |key, value| log.info "#{key}: #{value}" }
+        log.info response.body
+      end
+  
+      case response
+      when Net::HTTPSuccess
+        response
+      when Net::HTTPRedirection
+        if state[:warn_on_redirect]
+          log.warn "The web server redirected to " + response['location'] + 
+          ". You should revise your connection hostname or fix your server configuration if possible to improve performance."
+        end
+        newloc = URI.parse(response['location'])
+        http_fetch(newloc.host, newloc.port, newloc.request_uri, account_name, password, post_data, limit - 1)
+      when Net::HTTPUnauthorized
+        msg = "The account name (#{account_name}) or password provided is not correct (or the account doesn't have the fmxml extended privilege)."
+        raise Rfm::AuthenticationError.new(msg)
+      when Net::HTTPNotFound
+        msg = "Could not talk to FileMaker because the Web Publishing Engine is not responding (server returned 404)."
+        raise Rfm::CommunicationError.new(msg)
+      else
+        msg = "Unexpected response from server: #{response.code} (#{response.class.to_s}). Unable to communicate with the Web Publishing Engine."
+        raise Rfm::CommunicationError.new(msg)
+      end
+    end
+  
+    def expand_options(options)
+      result = {}
+      field_mapping = options.delete(:field_mapping) || {}
+      options.each do |key,value|
+        case key.to_sym
+        when :max_portal_rows
+        	result['-relatedsets.max'] = value
+        	result['-relatedsets.filter'] = 'layout'
+        when :ignore_portals
+        	result['-relatedsets.max'] = 0
+        	result['-relatedsets.filter'] = 'layout'
+        when :max_records
+          result['-max'] = value
+        when :skip_records
+          result['-skip'] = value
+        when :sort_field
+          if value.kind_of? Array
+            raise Rfm::ParameterError.new(":sort_field can have at most 9 fields, but you passed an array with #{value.size} elements.") if value.size > 9
+            value.each_index { |i| result["-sortfield.#{i+1}"] = field_mapping[value[i]] || value[i] }
+          else
+            result["-sortfield.1"] = field_mapping[value] || value
+          end
+        when :sort_order
+          if value.kind_of? Array
+            raise Rfm::ParameterError.new(":sort_order can have at most 9 fields, but you passed an array with #{value.size} elements.") if value.size > 9
+            value.each_index { |i| result["-sortorder.#{i+1}"] = value[i] }
+          else
+            result["-sortorder.1"] = value
+          end
+        when :post_script
+          if value.class == Array
+            result['-script'] = value[0]
+            result['-script.param'] = value[1]
+          else
+            result['-script'] = value
+          end
+        when :pre_find_script
+          if value.class == Array
+            result['-script.prefind'] = value[0]
+            result['-script.prefind.param'] = value[1]
+          else
+            result['-script.presort'] = value
+          end
+        when :pre_sort_script
+          if value.class == Array
+            result['-script.presort'] = value[0]
+            result['-script.presort.param'] = value[1]
+          else
+            result['-script.presort'] = value
+          end
+        when :response_layout
+          result['-lay.response'] = value
+        when :logical_operator
+          result['-lop'] = value
+        when :modification_id
+          result['-modid'] = value
+        else
+          raise Rfm::ParameterError.new("Invalid option: #{key} (are you using a string instead of a symbol?)")
+        end
+      end
+      return result
+    end  
+  
+  end # Connection
+
+  
+end # Rfm

data/lib/rfm/utilities/core_ext.rb

@@ -160,4 +160,17 @@ class Time
 		end
 		[d,t]
 	end
-end # Time
+end # Time
+
+class String
+	def title_case
+		self.gsub(/\w+/) do |word|
+		  word.capitalize
+		end
+	end
+end # String
+
+
+
+
+

data/lib/rfm/utilities/factory.rb

@@ -8,7 +8,10 @@
 
 module Rfm
 
-  module Factory 
+  module Factory
+  	# Acquired from Rfm::Base
+  	@models ||= []
+  	
   	extend Config
   	config :parent=>'Rfm::Config'
   
@@ -17,39 +20,36 @@ module Rfm
       def [](*args)
       	options = Factory.get_config(*args)
       	host = options[:strings].delete_at(0) || options[:host]
-        super(host) or (self[host] = Rfm::Server.new(host, options.rfm_filter(:account_name, :password, :delete=>true)))
+        super(host) || (self[host] = Rfm::Server.new(*args))   #(host, options.rfm_filter(:account_name, :password, :delete=>true)))
         # This part reconfigures the named server, if you pass it new config in the [] method.
         # This breaks some specs in all [] methods in Factory. Consider undoing this. See readme-dev.
 				#   super(host).config(options) if (options)
 				#   super(host)
       end
-			
-			# Potential refactor
-			# 		def [](*conf)
-			# 			options = Factory.get_config(*conf)
-			#   		server_name = options[:strings][0] || options[:host]
-			#   		options[:host] = server_name
-			# 			#server = servers[server_name, options]
-			# 			super(server_name) or (self[server_name] = Rfm::Server.new(options.reject{|k,v| [:account_name, :password].include? k}))
-			# 		end
     
     end # ServerFactory
     
     
     class DbFactory < Rfm::CaseInsensitiveHash # :nodoc: all
     
+# 	  	extend Config
+# 	  	config :parent=>'@server'
+
+    
       def initialize(server)
+	  	extend Config
+	  	config :parent=>'@server'
         @server = server
         @loaded = false
       end
       
       def [](*args)
       	# was: (dbname, acnt=nil, pass=nil)
-      	options = Factory.get_config(*args)
+      	options = get_config(*args)
       	name = options[:strings].delete_at(0) || options[:database]
-      	account_name = options[:strings].delete_at(0) || options[:account_name]
-      	password = options[:strings].delete_at(0) || options[:password]
-        super(name) or (self[name] = Rfm::Database.new(name, account_name, password, @server))
+      	#account_name = options[:strings].delete_at(0) || options[:account_name]
+      	#password = options[:strings].delete_at(0) || options[:password]
+        super(name) || (self[name] = Rfm::Database.new(@server, *args))  #(name, account_name, password, @server))
         # This part reconfigures the named database, if you pass it new config in the [] method.
 				#   super(name).config({:account_name=>account_name, :password=>password}.merge(options)) if (account_name or password or options)
 				#   super(name)
@@ -57,18 +57,16 @@ module Rfm
       
       def all
         if !@loaded
-        	xml = @server.connect(@server.state[:account_name], @server.state[:password], '-dbnames', {}).body
-          Rfm::Resultset.new(xml, :server_object => @server).each {|record|
-            name = record['DATABASE_NAME']
-            self[name] = Rfm::Database.new(name, @server) if self.keys.find{|k| k.to_s.downcase == name.to_s.downcase} == nil
-          }
+					c = Connection.new('-dbnames', {}, {:grammar=>'FMPXMLRESULT'}, @server)
+					c.parse('fmpxml_minimal.yml', {})['data'].each{|k,v| (self[k] = Rfm::Database.new(v['text'], @server)) if k.to_s != '' && v['text']}
+					#r = c.parse('fmpxml_minimal.yml', {})
           @loaded = true
         end
         self
       end
       
       def names
-      	keys
+      	self.values.collect{|v| v.name}
       end
     
     end # DbFactory
@@ -76,17 +74,22 @@ module Rfm
     
     
     class LayoutFactory < Rfm::CaseInsensitiveHash # :nodoc: all
-    
+
+# 	  	extend Config
+# 	  	config :parent=>'@database'
+    	
       def initialize(server, database)
+	  	extend Config
+	  	config :parent=>'@database'
         @server = server
         @database = database
         @loaded = false
       end
       
       def [](*args) # was layout_name
-      	options = Factory.get_config(*args)
+      	options = get_config(*args)
       	name = options[:strings].delete_at(0) || options[:layout]
-        super(name) or (self[name] = Rfm::Layout.new(name, @database, options))
+        super(name) || (self[name] = Rfm::Layout.new(@database, *args))   #(name, @database, options))
         # This part reconfigures the named layout, if you pass it new config in the [] method.
 				#   super(name).config({:layout=>name}.merge(options)) if options
 				#   super(name)
@@ -94,38 +97,45 @@ module Rfm
       
       def all
         if !@loaded
-	        get_layout_names.each {|record|
-	          name = record['LAYOUT_NAME']
-	        	begin
-	          	(self[name] = Rfm::Layout.new(name, @database)) unless !self[name].nil? or name.to_s.strip == ''
-	          rescue
-	          	$stderr.puts $!
-	          end
-	        }
+					c = Connection.new('-layoutnames', {"-db" => @database.name}, {:grammar=>'FMPXMLRESULT'}, @database)
+					c.parse('fmpxml_minimal.yml', {})['data'].each{|k,v| (self[k] = Rfm::Layout.new(v['text'], @database)) if k.to_s != '' && v['text']}
           @loaded = true
         end
         self
       end
-      
-      def get_layout_names_xml
-      	@server.connect(@database.account_name, @database.password, '-layoutnames', {"-db" => @database.name})
-      end
-      
-      def get_layout_names
-      	#Rfm::Resultset.new(@server, get_layout_names_xml.body, nil)
-      	Rfm::Resultset.new(get_layout_names_xml.body, :database_object => @database)
-      end
     
     	def names
-    		keys
+    		values.collect{|v| v.name}
+    	end
+    	
+    	# Acquired from Rfm::Base
+    	def modelize(filter = /.*/)
+    		all.values.each{|lay| lay.modelize if lay.name.match(filter)}
+    		models
+    	end
+    	
+    	# Acquired from Rfm::Base
+    	def models
+	    	rslt = {}
+    		each do |k,lay|
+    			layout_models = lay.models
+    			rslt[k] = layout_models if (!layout_models.nil? && !layout_models.empty?)
+	    	end
+	    	rslt
     	end
+    	
     end # LayoutFactory
     
     
     
     class ScriptFactory < Rfm::CaseInsensitiveHash # :nodoc: all
+
+# 	  	extend Config
+# 	  	config :parent=>'@database'
     
       def initialize(server, database)
+	  	extend Config
+	  	config :parent=>'@database'
         @server = server
         @database = database
         @loaded = false
@@ -137,18 +147,15 @@ module Rfm
       
       def all
         if !@loaded
-        	xml = @server.connect(@database.account_name, @database.password, '-scriptnames', {"-db" => @database.name}).body
-          Rfm::Resultset.new(xml, :database_object => @database).each {|record|
-            name = record['SCRIPT_NAME']
-            self[name] = Rfm::Metadata::Script.new(name, @database) if self[name] == nil
-          }
+					c = Connection.new('-scriptnames', {"-db" => @database.name}, {:grammar=>'FMPXMLRESULT'}, @database)
+					c.parse('fmpxml_minimal.yml', {})['data'].each{|k,v| (self[k] = Rfm::Metadata::Script.new(v['text'], @database)) if k.to_s != '' && v['text']}
           @loaded = true
         end
         self
       end
  
  			def names
- 				keys
+ 				values.collect{|v| v.name}
  			end
     
     end # ScriptFactory
@@ -156,6 +163,16 @@ module Rfm
     
     
     class << self
+    
+    	# Acquired from Rfm::Base
+  		attr_accessor :models
+	  	# Shortcut to Factory.db().layouts.modelize()
+	  	# If first parameter is regex, it is used for modelize filter.
+	  	# Otherwise, parameters are passed to Factory.database
+	  	def modelize(*args)
+	  		regx = args[0].is_a?(Regexp) ? args.shift : /.*/
+	  		db(*args).layouts.modelize(regx)
+	  	end
     	
 			def servers
 				@servers ||= ServerFactory.new
@@ -163,33 +180,19 @@ module Rfm
     
 	  	# Returns Rfm::Server instance, given config hash or array
 	  	def server(*conf)
-	  		options = get_config(*conf)
-				#server = servers[server_name, options]
-				# These disconnect servers from the ServerFactory hash, but it breaks the ActiveModel spec suite.
-				#Rfm::Server.new(server_name, options.rfm_filter(:account_name, :password, :delete=>true))
-				Rfm::Server.new(options)
+				Server.new(*conf)
 		  end
-			# Potential refactor
-			#def_delegator 'Rfm::Factory::ServerFactory', :[], :server  #, :[]
 	  
 		  # Returns Rfm::Db instance, given config hash or array
 		  def db(*conf)
-		  	options = get_config(*conf)
-		  	name = options[:strings].delete_at(0) || options[:database]
-		  	account_name = options[:strings].delete_at(0) || options[:account_name]
-		  	password = options[:strings].delete_at(0) || options[:password]
-				s = server(options)
-				s[name, account_name, password, options]
+				Database.new(*conf)
 		  end
 		  
 		  alias_method :database, :db
 		  
 		  # Returns Rfm::Layout instance, given config hash or array
 	  	def layout(*conf)
-	  		options = get_config(*conf)
-	  		name = options[:strings].delete_at(0) || options[:layout]
-				d = db(options)
-				d[name, options]
+				Layout.new(*conf)
 	  	end
 
     end # class << self