ginjo-rfm 3.0.11 → 3.0.12

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    M2MxNTI1ZTEyNTc4NjNkYzQ3OTFlNDNlZTVjODFkN2FlNTBiZWUyNw==
-  data.tar.gz: !binary |-
-    OGRkNjViNjkxNjQ5NWMzNWI3OGI3MzE4ZjQ2Zjk4MTYwZDU2N2ZmYw==
+SHA1:
+  metadata.gz: 9764299badd35b9f4b648765216cc32493d00a0b
+  data.tar.gz: ba30aa950a0e9ff80832e605efbcb70da4575286
 SHA512:
-  metadata.gz: !binary |-
-    MjM5ZGE5ODFjNmY0NDdhNzYxMDNhOTBjY2VlMDdkMTZhMGFkMDJiMWU2ZTVl
-    OWQzNmRiMDM5MjMzY2RhZjI2MTVkZWNiMTlkNjIyZWMzNTVjZmY5Y2QxODMx
-    NWRhZjI0OTQyYzhhODI5MzMzNmY3MjIyODI4NmU1NzM2ZjI3ODI=
-  data.tar.gz: !binary |-
-    MGEyMzYxYmM2MjYyN2MyMjdmNzMxZmQzZDEzMDNiNjRhNzhiNTM0NjE0ZDMz
-    YjMyNDFkMTBhMTVmNWVhM2U4ZmIzMWZmZDZhODFjYjA3ZjVhMTYzMWJiNjlm
-    NTFhN2M3NjAwZjI4NGJmMjc4ZGZhNmUzNDQyOTViNjZiZmZkYTA=
+  metadata.gz: fceed96b77df4acb9d368ae7f406cce69f3236009fc8ccbe58d6fe9ce1b52b6a4534935827604dcb45a0fe9e1e77952e5162d363f4178127a0167f7150dfdd2d
+  data.tar.gz: 1d0dcc307977a810fa9f11e381ebe0981c74c9916f25697e437bf85dceaee6a5e3ffee8f54d5c7de9484d497bbae28e5d2aef63cf8318066116fe7a839331c80

data/CHANGELOG.md

@@ -1,11 +1,21 @@
 # Changelog
 
+## Ginjo-Rfm 3.0.12
+
+* Make decimal separator configurable, as FM-Server uses local number settings in result set.
+  Use configuration option `:decimal_separator`.
+
+* Fix broken spec for Ox sax parser.
+
+* Change dependency constraint for rspec to >= v2.
+
+
 ## Ginjo-Rfm 3.0.11
 
 * Scoping fixes, changes, additions:
 
   Now takes proc or array of hashes or hash.
-  
+
   Scope_args for scope proc now defaults to model instance.
 
   Now handles omits - puts them at end of request array.
@@ -13,7 +23,7 @@
 * Support for rom-fmp 0.0.4 - query chaining with compound fm queries.
 
 * Basic support for portal field writes.
-    
+
         record['my_relationship::my_field.0'] = 'Adds a new portal record with data for my_field, if auto-create enabled'
         record.update_attributes! 'my_relationship::my_field.3' => 'Updates my_field in 3rd portal record, if exists'
 
@@ -21,6 +31,7 @@
 
 * Fix CompoundQuery to handle nil values in query params.
 
+
 ## Ginjo-Rfm 3.0.10
 
 * Fixed bug where missing metadata would cause errors when creating/editing records.
@@ -29,7 +40,7 @@
 
         scope = {:person_id => current_user.person_id}
         Order.find([{:status => ['open', 'processing']}, {:omit => true, :item_count => "<1"}], :scope => scope)
-
+    
         class Orders < Rfm::Base
           SCOPE = Proc.new { {:expired => "=" } }
         end
@@ -56,20 +67,20 @@
 
 * Implemented proxy option for database connections thru a proxy server.
 
-    config :proxy=>['my.proxy.com', 8888]
-  
+        config :proxy=>['my.proxy.com', 8888]
+
 * Implemented erb parsing of config.yml
-  
+
 * Disabled ```:grammar => :auto``` option. The current xml parser cannot yet use the FMPXMLRESULT grammar for general queries.
 
 
 ## Ginjo-Rfm 3.0.7
 
 * Changed record creation so that generic records created from non-modelized layouts will be instances of Rfm::Record, instead of instances of a transient model class based on the layout. Transient model classes will foul up serialization and any number of other things. Records created from a user-defined model class will continue to be instances of the model class.
-    
+
         my_layout.find(12345).class  ==  Rfm::Record
         MyModel.find(12345).class    ==  MyModel
-    
+
 
 ## Ginjo-Rfm 3.0.6
 
@@ -181,9 +192,9 @@
 
 * Added grammar translation layer between xml parser and Rfm, allowing all supported xml grammars to be used with Rfm.
   This will also streamline changes/additions to Filemaker's xml grammar(s).
-  
+
 * Fixed case statement for ruby 1.9
- 
+
 * Configuration ```:use``` option now works for all Rfm objects that respond to ```config```.
 
 ## Ginjo-Rfm 2.0.2
@@ -233,11 +244,11 @@
 ## Ginjo-Rfm 1.4.2
 
 * Re-implemented:  
-  
+
   Layout#field\_controls
 
   Layout#value\_lists  
-  
+
 * Enhanced:  
 
   ValueListItem handles both display & data items now.
@@ -245,7 +256,7 @@
   Timeout feature from timting (github/timting/rfm).
 
   Added specs for Record#save.  
-  
+
 * Fixed:  
 
   [Bug] Getting & setting fields with symbol-based keys was producing error.
@@ -259,23 +270,23 @@
   server.db.all
   db.layout.all
   db.script.all  
-  
+
   Note: the "#all" method returns object names (as keys) only. The receiver of the method maintains the full object collection.  
 
   Example:  
-  
-        server.db.all #=> ['dbname1', 'dbname2', ...]
-        server.db     #=> a DbFactory object (descendant of Hash), containing 0 or more Database objects
+
+    server.db.all #=> ['dbname1', 'dbname2', ...]
+    server.db     #=> a DbFactory object (descendant of Hash), containing 0 or more Database objects
 
 ## Lardawge-Rfm 1.4.2 (unreleased)
-  
+
 * Made nil default on fields with no value.  
-  
+
   Example:
  
         Old: record.john #=> "" 
         New: record.john #=> nil
-   
+
 ## Lardawge-Rfm 1.4.1.2
 
 * [Bug] Pointing out why testing is soooooo important when refactoring... Found a bug in getter/setter method in Rfm::Record (yes, added spec for it).
@@ -295,13 +306,13 @@
 * Added an option to load portal records which defaults to false. This significantly speeds up load time when portals are present on the layout.
 
   Example:  
-  
+
         result = fm_server('layout').find({:username => "==#{username}"}, {:include_portals => true})
         # => This will fetch all records with portal records attached.
-
+    
         result.first.portals
         # => would return an empty hash by default.
-    
+
 * Internal file restructuring. Some classes have changed but it should be nothing a developer would use API wise. Please let me know if it is.
 
 * Removed Layout#value\_lists && Layout#field\_controls. Will put back in if the demand is high. Needs a major refactor and different placement if it goes back in. Was broken so it didn't seem to be used by many devs.

data/README.md

@@ -1,26 +1,24 @@
 <!--
-	See YARD documentation - https://github.com/lsegal/yard/wiki/GettingStarted
-	
-	Yard is not the same as markdown - Yard is for ruby and can use any markup language,
-	whereas Markdown is just another markup language.
-	
-	Rubydoc.info uses yard and can use markdown and other markup languages.
-	To update ginjo-rfm's yard documentation from github's master branch,
-	first find 'rfm' on rubydoc.info, then in list-view click the update button
-	on the right of the screen.
-	To preview this file in yard, run 'rake yard'
-	
-	Github uses markdown or rdoc (maybe others?).
-	To preview this file in plain markdown, edit in TextMate and
-	choose Bundles/Markdown/Preview menu option.
+  See YARD documentation - https://github.com/lsegal/yard/wiki/GettingStarted
+  
+  Yard is not the same as markdown - Yard is for ruby and can use any markup language,
+  whereas Markdown is just another markup language.
+  
+  Rubydoc.info uses yard and can use markdown and other markup languages.
+  To update ginjo-rfm's yard documentation from github's master branch,
+  first find 'rfm' on rubydoc.info, then in list-view click the update button
+  on the right of the screen.
+  To preview this file in yard, run 'rake yard'
+  
+  Github uses markdown or rdoc (maybe others?).
+  To preview this file in plain markdown, edit in TextMate and
+  choose Bundles/Markdown/Preview menu option.
 -->
 
 # ginjo-rfm
 
 Rfm is a Ruby-Filemaker adapter, a gem that provides an interface between Filemaker Server and Ruby. Query your Filemaker database, browse result records as persistent objects, and create/update/delete records with a syntax similar to ActiveRecord. Ginjo-rfm picks up from the lardawge-rfm gem and continues to refine code and fix bugs. Version 3 removes the dependency on ActiveSupport and is now a completely independent Gem, able to run most of its core features without requiring any other supporting Gems. ActiveModel features can be activated by adding activemodel to your Gemfile (or requiring activemodel manually).
 
-Ginjo-rfm version 3 has been tested successfully on Ruby 1.8.7 thru 2.1.3.
-
 
 ## Documentation & Links
 
@@ -72,22 +70,22 @@ The first step in getting connected to your Filemaker databases with Rfm (assumi
 
 config/rfm.yml
 
-		:host: my.host.com
-		:account_name: myname
-		:password: somepass
-		:database: MyFmDb
-	
+    :host: my.host.com
+    :account_name: myname
+    :password: somepass
+    :database: MyFmDb
+  
 app/models/order\_item.rb
 
-		class OrderItem < Rfm::Base
-		  config :layout => 'order_item_layout'
-		end
-			
+    class OrderItem < Rfm::Base
+      config :layout => 'order_item_layout'
+    end
+      
 app/controllers/order\_item\_controller.rb
 
-		def show
-			@record = OrderItem.find params[:id]
-		end
+    def show
+      @record = OrderItem.find params[:id]
+    end
 
 
 ### Configuration
@@ -96,42 +94,42 @@ In previous versions of Rfm, you may have stored your configuration settings in
 
 rfm.yml
 
-	   :ssl: true
-	   :timeout: 10
-	   :port: 443
-	   :host: my.host.com
-	   :account_name: myname
-	   :password: somepass
-	   :database: MyFmDb
+    :ssl: true
+    :timeout: 10
+    :port: 443
+    :host: my.host.com
+    :account_name: myname
+    :password: somepass
+    :database: MyFmDb
 
 Or put your configuration settings in a hash called RFM_CONFIG. Rfm will pick those up just as with the yaml file.
 
-	   RFM_CONFIG = {
-	     :host          => 'my.host.com',
-	     :database      => 'MyFmDb',
-	     :account_name  => 'myname',
-	     :password      => 'somepass',
-	     :ssl           => true,
-	     :port          => 443,
-	     :timeout       => 10
-	     }
+    RFM_CONFIG = {
+      :host          => 'my.host.com',
+      :database      => 'MyFmDb',
+      :account_name  => 'myname',
+      :password      => 'somepass',
+      :ssl           => true,
+      :port          => 443,
+      :timeout       => 10
+    }
 
 You can use configuration subgroups to separate global settings from environment-specific settings.
 
-	   :ssl: true
-	   :root_cert: false
-	   :timeout: 10
-	   :port: 443
-	   :development:
-	     :host: dev.mydomain.com
-	     :account_name: admin
-	     :password: pass
-	     :database: DevFmDb
-	   :production:
-	     :host: live.mydomain.com
-	     :account_name: admin
-	     :password: pass
-	     :database: LiveFmDb
+    :ssl: true
+    :root_cert: false
+    :timeout: 10
+    :port: 443
+    :development:
+      :host: dev.mydomain.com
+      :account_name: admin
+      :password: pass
+      :database: DevFmDb
+    :production:
+      :host: live.mydomain.com
+      :account_name: admin
+      :password: pass
+      :database: LiveFmDb
 
 Then in your environment files (or wherever you put environment-specific configuration in your Ruby project),
 specifiy which subgroup to use.
@@ -140,27 +138,27 @@ specifiy which subgroup to use.
 
 You can use configuration subgroups to contain any arbitrary groups of settings.
 
-	   :ssl: true
-	   :root_cert: false
-	   :timeout: 10
-	   :port: 443
-	   :customer1:
-	     :host: customer1.com
-	     :account_name: cust1
-	     :password: pass
-	     :database: custOneFmDb
-	   :customer2:
-	     :host: customer2.com
-	     :account_name: cust2
-	     :password: pass
-	     :database: custTwoFmDb
+    :ssl: true
+    :root_cert: false
+    :timeout: 10
+    :port: 443
+    :customer1:
+      :host: customer1.com
+      :account_name: cust1
+      :password: pass
+      :database: custOneFmDb
+    :customer2:
+      :host: customer2.com
+      :account_name: cust2
+      :password: pass
+      :database: custTwoFmDb
 
 Use the configuration setting method `config` to set configuration for specific objects, like Rfm models. When you pass a `:use => :subgroup` to the `config` method, you're saying use that subgroup of settings (on top of any existing upstream configuration).
 
-	   class MyModel < Rfm::Base
-	     config :use => :customer1, :layout => 'some_layout'
-	   end
-	
+    class MyModel < Rfm::Base
+      config :use => :customer1, :layout => 'some_layout'
+    end
+  
 The current hierarchy of configurable objects in Rfm, starting at the top, is:
 
 * rfm.yml      # file of settings in yaml format
@@ -172,132 +170,134 @@ The current hierarchy of configurable objects in Rfm, starting at the top, is:
 
 You can also include or extend the Rfm::Config module in any object in your project to gain Rfm configuration abilities for that object.
 
-	   module MyModule
-	     include Rfm::Config
-	     config :host => 'myhost.com', :database => 'mydb', :account_name => 'name', :password => 'pass'
-	     # inherits settings from Rfm::Config by default
-	   end
+    module MyModule
+      include Rfm::Config
+      config :host => 'myhost.com', :database => 'mydb', :account_name => 'name', :password => 'pass'
+      # inherits settings from Rfm::Config by default
+    end
 
-	   class Person < Rfm::Base
-	     config :parent => MyModule, :layout => 'some_layout'
-	     # using :parent to set where this object inherits config settings from
-	   end
+    class Person < Rfm::Base
+      config :parent => MyModule, :layout => 'some_layout'
+      # using :parent to set where this object inherits config settings from
+    end
 
 Use `get_config` to view the compiled configuration settings for any object. Configuration compilation will start at the top (rfm.yml), then work down the hierarchy of objects to wherever you call the `get_config` method, merging in all global settings along the way. Subgroupings of settings will also be merged, if they are specified in a subgroup filter. A subgroup filter occurs any time you put `:use => :subgroup` in your configuration setting. You can have multiple subgroup filters, and when configuration compilation occurs, all subgroup filters are stacked up into an array and processed in order (as if you typed `:use=>[:subgroup1, :subgroup2, subgroup3, ...]` which is also allowed). `get_config` returns a compiled configuration hash, leaving all configuration settings in all modules and classes un-touched.
 
-	   Person.get_config
-	
-	   # =>  {:ssl => true, :timeout => 10, :root_cert => false, :port => 443,
-	          :host => 'myhost', :database => 'mydb', :layout => 'some_layout',
-	          :account_name => 'name', :password => 'pass'
-	         }
-	
+    Person.get_config
+    
+    # =>  {:ssl => true, :timeout => 10, :root_cert => false, :port => 443,
+          :host => 'myhost', :database => 'mydb', :layout => 'some_layout',
+          :account_name => 'name', :password => 'pass'
+          }
+  
 #### Configuration Options
 
 Following are all of the recognized configuration options, including defaults if applicable.
 See `Rfm::Config::CONFIG_KEYS` for a list of currently allowed configuration options.
 
-	   :host             => 'localhost'
-	   :port             
-	   :ssl              => true
-	   :root_cert        => true
-	   :root_cert_name   => ''
-	   :root_cert_path   => '/'
-	   :account_name     => ''
-	   :password         => ''
-	   :proxy            => false                         # Pass an array of Net::HTTP::Proxy options (p_addr, p_port = nil, p_user = nil, p_pass = nil).
-	   :log_actions      => false
-	   :log_responses    => false
-	   :log_parser       => false
-	   :warn_on_redirect => true
-	   :raise_on_401     => false
-	   :timeout          => 60
-	   
-	   :use                                               # Use configuration subgroups, or filter configuration subgoups.
-	   :layout                                            # Specify the name of the layout to use.
-	   :parent           => 'Rfm::Config'                 # The parent configuration object of the current configuration object, as string.
-	   :file_name        => 'rfm.yml                      # Name of configuration file to load yaml from.
-	   :file_path        => ['', 'config/']               # Array of additional file paths to look for configuration file.
-	   :parser                                            # Prefferred XML parser. Can be :libxml, :nokogiri, :ox, :rexml.
-	                                                      # You must also require the parsing gem or specify it in your gemfile,
-	                                                      # if not using the built-in Ruby XML parser REXML. 
-	                                                      # You only need to use this option if you have multiple
-	                                                      # parsing gems loaded and want to use a specfic one. 
-	                                                      # Otherwise, Rfm will use the best parser it can find amongst your currently loaded parsing gems.
-	   :ignore_bad_data  => nil                           # Instruct Rfm to ignore data mismatch errors when loading a resultset.
-	
+    :host             => 'localhost'
+    :port             
+    :ssl              => true
+    :root_cert        => true
+    :root_cert_name   => ''
+    :root_cert_path   => '/'
+    :account_name     => ''
+    :password         => ''
+    :proxy            => false              # Pass an array of Net::HTTP::Proxy options (p_addr, p_port = nil, p_user = nil, p_pass = nil).
+    :log_actions      => false
+    :log_responses    => false
+    :log_parser       => false
+    :warn_on_redirect => true
+    :raise_on_401     => false
+    :timeout          => 60
+    
+    :use                                    # Use configuration subgroups, or filter configuration subgoups.
+    :layout                                 # Specify the name of the layout to use.
+    :parent           => 'Rfm::Config'      # The parent configuration object of the current configuration object, as string.
+    :file_name        => 'rfm.yml           # Name of configuration file to load yaml from.
+    :file_path        => ['', 'config/']    # Array of additional file paths to look for configuration file.
+    :parser                                 # Prefferred XML parser. Can be :libxml, :nokogiri, :ox, :rexml.
+                                            # You must also require the parsing gem or specify it in your gemfile,
+                                            # if not using the built-in Ruby XML parser REXML. 
+                                            # You only need to use this option if you have multiple
+                                            # parsing gems loaded and want to use a specfic one. 
+                                            # Otherwise, Rfm will use the best parser it can find amongst your currently loaded parsing gems.
+    :ignore_bad_data   => nil                # Instruct Rfm to ignore data mismatch errors when loading a resultset.
+    :decimal_separator => '.'               # FileMaker uses local number format of the server. It stores input as text.
+                                            # So on european servers a number value of '1.200,50' is considered valid and interpreted as 1200.5
+                                            # To support this, :decimal_separator can be configured and any other characters than digits and the separator are ignored
 
 ### Using Models
 
 Rfm models provide easy access, modeling, and persistence of your Filemaker data. A ginjo-rfm model is basically an alias to a specific layout in your Filemaker database and provides all of the query options found in a classic rfm layout object. The model and/or the layout object is where you do most of your work with rfm. For more details about what methods and options are available to a model or layout object, see the documentation for the {Rfm::Layout} and {Rfm::Base} classes.
 
-	   class User < Rfm::Base
-	     config :layout => 'my_user_layout'
-	     attr_accessor :password
-	   end
-	
-	   @user = User.new(:login => 'bill', :password => 'xxxxxxxx', :email => 'my@email.com')
-	   @user.encrypt_password
-	   @user.save!
-	
-	   @user.record_id
-	   # => '12345'
-
-	   @user.field_names
-	   # => ['login', 'encryptedPassword', 'email', 'groups', 'lastLogin' ]
-	
-	   User.total_count
-	   # => 35467
-
-	   @user = User.find 12345
-	   @user.update_attributes(:login => 'william', :email => 'myother@email.com')
-	   @user.save!
-	
+    class User < Rfm::Base
+      config :layout => 'my_user_layout'
+      attr_accessor :password
+    end
+    
+    @user = User.new(:login => 'bill', :password => 'xxxxxxxx', :email => 'my@email.com')
+    @user.encrypt_password
+    @user.save!
+    
+    @user.record_id
+    # => '12345'
+    
+    @user.field_names
+    # => ['login', 'encryptedPassword', 'email', 'groups', 'lastLogin' ]
+    
+    User.total_count
+    # => 35467
+    
+    @user = User.find 12345
+    @user.update_attributes(:login => 'william', :email => 'myother@email.com')
+    @user.save!
+  
 If using Rails, put your model code in files within your models/ directory.
 
 app/models/user.rb
 
-	   class User < Rfm::Base
-	     config :layout => 'user_layout'
-	   end
+    class User < Rfm::Base
+      config :layout => 'user_layout'
+    end
 
 If you prefer, you can create models on-the-fly from any layout.
 
-	   my_rfm_layout_object.modelize
-
-	   # => MyLayoutName   (subclassed from Rfm::Base, represented by your layout's name)
+    my_rfm_layout_object.modelize
+    
+    # => MyLayoutName   (subclassed from Rfm::Base, represented by your layout's name)
 
 Or create models for an entire database, all at once.
 
-	   Rfm.modelize /_xml/i, 'my_database', :my_config_group
-
-	   # => [MyLayoutXml, AnotherLayoutXml, ThirdLayoutXml, AndSoOnXml, ...]
-	   # The regex in the first parameter is optional and filters the layout names in the specified database.
-	   # Omit the regex parameter to modelize all possible layouts in the specified database (careful with this one!).
+    Rfm.modelize /_xml/i, 'my_database', :my_config_group
+    
+    # => [MyLayoutXml, AnotherLayoutXml, ThirdLayoutXml, AndSoOnXml, ...]
+    # The regex in the first parameter is optional and filters the layout names in the specified database.
+    # Omit the regex parameter to modelize all possible layouts in the specified database (careful with this one!).
 
 With ActiveModel loaded, you get callbacks, validations, errors, serialization, and a handful of other features extracted from Rails ActiveRecord. Not all ActiveModel features are supported (yet) in ginjo-rfm, but adapters can be hand-rolled in the meantime.
 
 In your Gemfile
 
-	   gem 'activemodel'
-	
+    gem 'activemodel'
+
 Or without Bundler
 
-	   require 'active_model'
-	
+    require 'active_model'
+
 Then use ActiveModel features in your Rfm models
 
-	   class MyModel < Rfm::Base
-	     before_create    :encrypt_password
-	     after_validate   "puts 'yay!'"
-	     validates        :email, :presence => true
-	   end
-	
-	   @my_model = MyModel.new
-	   @my_model.valid?
-	   @my_model.save!
-	   @my_model.errors
-	
+    class MyModel < Rfm::Base
+      before_create    :encrypt_password
+      after_validate   "puts 'yay!'"
+      validates        :email, :presence => true
+    end
+
+    @my_model = MyModel.new
+    @my_model.valid?
+    @my_model.save!
+    @my_model.errors
+
 To learn more about ActiveModel, see the ActiveModel or RubyOnRails documentation:
 
 * <http://rubydoc.info/gems/activemodel/frames>
@@ -310,8 +310,8 @@ Once you have an Rfm model or layout, you can use any of the standard Rfm comman
 
 (From Rfm v2 onward) When using Models to retrieve records using the `any` method or the `find(record_id)` method, the return values will be single Rfm::Record objects. This differs from the original Rfm behavior of these methods when accessed directly from the the Rfm::Layout instance, where the return value is always a Rfm::Resultset.
 
-	   MyModel.find(record_id)  ==  my_layout.find(record_id)[0]
-	   MyModel.any              ==  my_layout.any[0]
+    MyModel.find(record_id)  ==  my_layout.find(record_id)[0]
+    MyModel.any              ==  my_layout.any[0]
 
 
 ### Getting Rfm Server, Database, and Layout Objects Manually
@@ -320,36 +320,36 @@ Well... not entirely manually. To get server, db, and layout objects as in previ
 
 Create a layout object using default configuration settings.
 
-	   my_layout = Rfm.layout 'layout_name'
-	
+    my_layout = Rfm.layout 'layout_name'
+  
 Create a layout object using a subgroup of configuration settings.
 
-	   my_layout = Rfm.layout :subgroup_name
-	
+    my_layout = Rfm.layout :subgroup_name
+  
 Create a layout object passing in a layout name, multiple config subgroups to merge, and specific settings.
 
-	   my_layout = Rfm.layout 'layout_name', :other_server, :log_actions => true
-	
+    my_layout = Rfm.layout 'layout_name', :other_server, :log_actions => true
+  
 The same can be done for servers and databases.
 
-	   my_server   = Rfm.server 'my.host.com'
-	   my_database = Rfm.database :development, :ssl => false, :root_cert => false 
-	   my_database = Rfm.db :production
-	     # db and database are interchangeable aliases in Ginjo-rfm 2.0
-	
+    my_server   = Rfm.server 'my.host.com'
+    my_database = Rfm.database :development, :ssl => false, :root_cert => false 
+    my_database = Rfm.db :production
+    # db and database are interchangeable aliases in Ginjo-rfm 2.0
+  
 You can query your Filemaker objects for the familiar meta-data.
 
-	   my_server.databases.all.names
-	   my_server.databases['MyFmDb']
-	   my_database.layouts
-	   my_layout.value_lists
-	   my_layout.field_names
-	   my_layout.portal_meta
+    my_server.databases.all.names
+    my_server.databases['MyFmDb']
+    my_database.layouts
+    my_layout.value_lists
+    my_layout.field_names
+    my_layout.portal_meta
 
 Here are two new fun Layout methods:
 
-	   my_layout.total_count # => total records in table
-	   my_layout.count(:some_field => 'search criteria', ...)   # Returns foundset_count only, no records.
+    my_layout.total_count # => total records in table
+    my_layout.count(:some_field => 'search criteria', ...)   # Returns foundset_count only, no records.
 
 See the API documentation for the lowdown on new methods in Rfm Server, Database, and Layout objects.
 
@@ -359,60 +359,60 @@ All Rfm methods that take a configuration hash have two possible shortcuts.
 
 (1) If you pass a symbol before the hash, it is interpreted as subgroup specification or subgroup filter
 
-	   config :mygroup, :layout => 'mylayout'
-	   # This will add the following configuration options to the object you called 'config' on.
-	   # :use => :mygroup, :layout => 'mylayout'
-	
-	   get_config :othergroup
-	   # This will return global configuration options merged with configuration options from :othergroup.
-	   # :use => [:mygroup, :othergroup], :layout => 'mylayout'
+    config :mygroup, :layout => 'mylayout'
+    # This will add the following configuration options to the object you called 'config' on.
+    # :use => :mygroup, :layout => 'mylayout'
+  
+    get_config :othergroup
+    # This will return global configuration options merged with configuration options from :othergroup.
+    # :use => [:mygroup, :othergroup], :layout => 'mylayout'
 
 (2) If you pass a string before any symbols or hashes, it is interpreted as one of several possible configuration settings - usually a layout name, a database name, or a server hostname. The interpretation is dependent on the method being called. Not all methods will make use of a string parameter.
 
-	   class MyModel < Rfm::Base
-	     config 'MyLayoutName'
-	     # In this context, this is the same as
-	     # config :layout => 'MyLayoutName'
-	   end
-	
-	   Rfm.database 'MyDatabaseName'
-	   # In this context, this is the same as
-	   # Rfm.database :database => 'MyDatabaseName'
-	
-	   Rfm.modelize 'MyDatabaseName', :group1
-	   # In this context, this is the same as
-	   # Rfm.modelize :database => 'MyDatabaseName', :use => :group1
+    class MyModel < Rfm::Base
+      config 'MyLayoutName'
+      # In this context, this is the same as
+      # config :layout => 'MyLayoutName'
+    end
+  
+    Rfm.database 'MyDatabaseName'
+    # In this context, this is the same as
+    # Rfm.database :database => 'MyDatabaseName'
+  
+    Rfm.modelize 'MyDatabaseName', :group1
+    # In this context, this is the same as
+    # Rfm.modelize :database => 'MyDatabaseName', :use => :group1
 
 Just about anything you can do with a Rfm layout, you can also do with a Rfm model.
 
-	   MyModel.total_count
-	   MyModel.field_names
-	   MyModel.database.name
-	
+    MyModel.total_count
+    MyModel.field_names
+    MyModel.database.name
+  
 There are a number of methods within Rfm that have been made accessible from the top-level Rfm module. Note that the server/database/layout methods are new to Rfm and are not the same as Rfm::Server, Rfm::Database, and Rfm::Layout. See the above section on "Getting Rfm Server, Database, and Layout Objects Manually" for an overview of how to use the new server/database/layout methods.
 
-	   # Any of these methods can be accessed via Rfm.<method_name>
-	   
-	   Rfm::Factory    :servers, :server, :db, :database, :layout, :models, :modelize
-	   Rfm::Config     :config, :get_config, :config_clear
-	   Rfm::Resultset  :ignore_bad_data
-	   Rfm::SaxParser  :backend
-	
+    # Any of these methods can be accessed via Rfm.<method_name>
+    
+    Rfm::Factory    :servers, :server, :db, :database, :layout, :models, :modelize
+    Rfm::Config     :config, :get_config, :config_clear
+    Rfm::Resultset  :ignore_bad_data
+    Rfm::SaxParser  :backend
+  
 If you are working with a Filemaker database that returns codes like '?' for a missing value in a date field, Rfm will throw an error. Set your main configuration, your server, or your layout to `ignore_bad_data true`, if you want Rfm to silently ignore data mismatch errors when loading resultset data. If ActiveRecord is loaded, and your resultset is loaded into a Rfm model, your model records will log these errors in the @errors attribute.
 
-	   Rfm.config :ignore_bad_data => true
-	   
-	   class MyModel < Rfm::Base
-	     config 'my_layout'
-	   end
-	   
-	   result = MyModel.find(:name => 'mike')
-	   # Assuming the Filemaker field 'some_date_field' contains a bad date value '?'
-	   result[0].errors.full_messages
-	   # ['some_date_field invalid date']
-	
-	   # To be more specific about what objects you want to ignore data errors
-	   MyModel.layout.ignore_bad_data true
+    Rfm.config :ignore_bad_data => true
+    
+    class MyModel < Rfm::Base
+      config 'my_layout'
+    end
+    
+    result = MyModel.find(:name => 'mike')
+    # Assuming the Filemaker field 'some_date_field' contains a bad date value '?'
+    result[0].errors.full_messages
+    # ['some_date_field invalid date']
+    
+    # To be more specific about what objects you want to ignore data errors
+    MyModel.layout.ignore_bad_data true
 
 ## Working with "Classic" Rfm Features
 
@@ -424,93 +424,93 @@ All of Rfm's original features and functions are available as they were before,
 IMPORTANT:SSL and Certificate verification are on by default. Please see Server#new in rdocs for explanation and setup.
 You connect with the Rfm::Server object. This little buddy will be your window into FileMaker data.
 
-	   require 'rfm'
+    require 'rfm'
 
-	   my_server = Rfm::Server.new(
-	     :host           => 'myservername',
-	     :account_name   => 'user',
-	     :password       => 'pw',
-	     :ssl            => false
-	   )
+    my_server = Rfm::Server.new(
+      :host           => 'myservername',
+      :account_name   => 'user',
+      :password       => 'pw',
+      :ssl            => false
+    )
 
 if your web publishing engine runs on a port other than 80, you can provide the port number as well:
 
-	   my_server = Rfm::Server.new(
-	     :host           => 'myservername',
-	     :account_name   => 'user',
-	     :password       => 'pw',
-	     :port           => 8080, 
-	     :ssl            => false,
-	     :root_cert      => false
-	   )
+    my_server = Rfm::Server.new(
+      :host           => 'myservername',
+      :account_name   => 'user',
+      :password       => 'pw',
+      :port           => 8080, 
+      :ssl            => false,
+      :root_cert      => false
+    )
 
 ### Databases and Layouts
 
 All access to data in FileMaker's XML interface is done through layouts, and layouts live in databases. The Rfm::Server object has a collection of databases called 'db'. So to get ahold of a database called "My Database", you can do this:
 
-	   my_db = my_server.db["My Database"]
+    my_db = my_server.db["My Database"]
 
 As a convenience, you can do this too:
 
-	   my_db = my_server["My Database"]
+    my_db = my_server["My Database"]
 
 Finally, if you want to introspect the server and find out what databases are available, you can do this:
 
-	   all_dbs = my_server.db.all
+    all_dbs = my_server.db.all
 
 In any case, you get back Rfm::Database objects. A database object in turn has a property called "layout":
 
-	   my_layout = my_db.layout["My Layout"]
+    my_layout = my_db.layout["My Layout"]
 
 Again, for convenience:
 
-	   my_layout = my_db["My Layout"]
+    my_layout = my_db["My Layout"]
 
 And to get them all:
 
-	   all_layouts = my_db.layout.all
+    all_layouts = my_db.layout.all
 
 Bringing it all together, you can do this to go straight from a server to a specific layout:
 
-	   my_layout = my_server["My Database"]["My Layout"]
+    my_layout = my_server["My Database"]["My Layout"]
 
 ### Working with Layouts
 
 Once you have a layout object, you can start doing some real work. To get every record from the layout:
 
-	   my_layout.all   # be careful with this
+    my_layout.all   # be careful with this
 
 To get a random record:
 
-	   my_layout.any
+    my_layout.any
 
 To find every record with "Arizona" in the "State" field:
 
-	   my_layout.find({"State" => "Arizona"})
+    my_layout.find({"State" => "Arizona"})
 
 To add a new record with my personal info:
 
-	   my_layout.create({
-	     :first_name   => "Geoff",
-	     :last_name    => "Coffey",
-	     :email        => "gwcoffey@gmail.com"}
-	   )
+    my_layout.create({
+      :first_name   => "Geoff",
+      :last_name    => "Coffey",
+      :email        => "gwcoffey@gmail.com"}
+    )
 
 Notice that in this case I used symbols instead of strings for the hash keys. The API will accept either form, so if your field names don't have whitespace or punctuation, you might prefer the symbol notation.
 
 To edit the record whose recid (filemaker internal record id) is 200:
 
-	   my_layout.edit(200, {:first_name => 'Mamie'})
+    my_layout.edit(200, {:first_name => 'Mamie'})
 
 Note: See the "Record Objects" section below for more on editing records.
 
 To delete the record whose recid is 200:
 
-	   my_layout.delete(200)
+    my_layout.delete(200)
 
 All of these methods return an Rfm::Resultset object (see below), and every one of them takes an optional parameter (the very last one) with additional options. For example, to find just a page full of records, you can do this:
 
-	   my_layout.find({:state => "AZ"}, {:max_records => 10, :skip_records => 100})
+    my_layout.find({:state => "AZ"}, {:max_records => 10, :skip_records => 100})
 
 For a complete list of the available options, see the "Common Options" section in the layout.rb file.
 
@@ -521,24 +521,24 @@ Finally, if filemaker returns an error when executing any of these methods, an e
 
 Any method on the Layout object that returns data will return a Resultset object. Rfm::Resultset is a subclass of Array, so first and foremost, you can use it like any other array:
 
-	   my_result = my_layout.any
-	   my_result.size  # returns '1'
-	   my_result[0]    # returns the first record (an Rfm::Record object)
+    my_result = my_layout.any
+    my_result.size  # returns '1'
+    my_result[0]    # returns the first record (an Rfm::Record object)
 
 The Resultset object also tells you information about the fields and portals in the result. Resultset#field\_meta and Resultset#portal\_meta are both standard Ruby hashes, with strings for keys. The fields hash has Rfm::Metadata::Field objects for values. The portals hash has another hash for its values. This nested hash is the fields on the portal. This would print out all the field names:
 
-	   my_result.field_meta.each { |name, field| puts name }
-	
+    my_result.field_meta.each { |name, field| puts name }
+  
 Or, as a convenience, you can do this:
 
     my_result.field_names
 
 This would print out the tables each portal on the layout is associated with. Below each table name, and indented, it will print the names of all the fields on each portal.
 
-	   my_result.portals.each { |table, fields|
-	     puts "table: #{table}"
-	     fields.each { |name, field| puts "\t#{name}"}
-	   }
+    my_result.portals.each { |table, fields|
+      puts "table: #{table}"
+      fields.each { |name, field| puts "\t#{name}"}
+    }
 
 Also as a convenience, you can do this:
 
@@ -546,67 +546,67 @@ Also as a convenience, you can do this:
 
 But most importantly, the Resultset contains record objects. Rfm::Record is a subclass of Hash, so it can be used in many standard ways. This code would print the value in the 'first_name' field in the first record of the Resultset:
 
-	   my_record = my_result[0]
-	   puts my_record["first_name"]
+    my_record = my_result[0]
+    puts my_record["first_name"]
 
 As a convenience, if your field names are valid Ruby method names (ie, they don't have spaces or odd punctuation in them), you can do this instead:
 
-	   puts my_record.first_name
+    puts my_record.first_name
 
 Since Resultsets are arrays and Records are hashes, you can take advantage of Ruby's wonderful expressiveness. For example, to get a comma-separated list of the full names of all the people in California, you could do this:
 
-	   my_layout.find(:state => 'CA').collect {|rec| "#{rec.first_name} #{rec.last_name}"}.join(", ")
+    my_layout.find(:state => 'CA').collect {|rec| "#{rec.first_name} #{rec.last_name}"}.join(", ")
 
 Record objects can also be edited:
 
-	   my_record.first_name = 'Isabel'
+    my_record.first_name = 'Isabel'
 
 Once you have made a series of edits, you can save them back to the database like this:
 
-	   my_record.save
+    my_record.save
 
 The save operation causes the record to be reloaded from the database, so any changes that have been made outside your script will also be picked up after the save.
 
 If you want to detect concurrent modification, you can do this instead:
 
-	   my_record.save_if_not_modified
+    my_record.save_if_not_modified
 
 This version will refuse to update the database and raise an error if the record was modified after it was loaded but before it was saved.
 
 Record objects also have portals. While the portals in a Resultset tell you about the tables and fields the portals show, the portals in a Record have the actual data. For example, if an Order record has Line Item records, you could do this:
 
-	   my_order = order_layout.any[0]  # the [0] is important!
-	   my_lines = my_order.portals["Line Items"]
+    my_order = order_layout.any[0]  # the [0] is important!
+    my_lines = my_order.portals["Line Items"]
 
 At the end of the previous block of code, my_lines is an array of Record objects. In this case, they are the records in the "Line Items" portal for the particular order record. You can then operate on them as you would any other record. 
 
 NOTE: Fields on a portal have the table name and the "::" stripped off of their names if they belong to the table the portal is tied to. In other words, if our "Line Items" portal includes a quantity field and a price field, you would do this:
 
-	   my_lines[0]["Quantity"]
-	   my_lines[0]["Price"]
+    my_lines[0]["Quantity"]
+    my_lines[0]["Price"]
 
 You would NOT do this:
 
-	   my_lines[0]["Line Items::Quantity"]
-	   my_lines[0]["Line Items::Quantity"]
+    my_lines[0]["Line Items::Quantity"]
+    my_lines[0]["Line Items::Quantity"]
 
 My feeling is that the table name is redundant and cumbersome if it is the same as the portal's table. This is also up for debate.
 
 Again, you can string things together with Ruby. This will calculate the total dollar amount of the order:
 
-	   total = 0.0
-	   my_order.portals["Line Items"].each {|line| total += line.quantity * line.price}
+    total = 0.0
+    my_order.portals["Line Items"].each {|line| total += line.quantity * line.price}
 
 ### Data Types
 
 FileMaker's field types are coerced to Ruby types thusly:
 
-	   Text Field       -> String object  
-	   Number Field     -> BigDecimal object  # see below  
-	   Date Field       -> Date object  
-	   Time Field       -> DateTime object # see below  
-	   TimeStamp Field  -> DateTime object  
-	   Container Field  -> URI object  
+    Text Field       -> String object  
+    Number Field     -> BigDecimal object  # see below  
+    Date Field       -> Date object  
+    Time Field       -> DateTime object # see below  
+    TimeStamp Field  -> DateTime object  
+    Container Field  -> URI object  
 
 FileMaker's number field is insanely robust. The only data type in Ruby that can handle the same magnitude and precision of a FileMaker number is Ruby's BigDecimal. (This is an extension class, so you have to require 'bigdecimal' to use it yourself). Unfortuantely, BigDecimal is not a "normal" Ruby numeric class, so it might be really annoying that your tiny filemaker numbers have to go this route. This is a great topic for debate.
 
@@ -614,9 +614,9 @@ Also, Ruby doesn't have a Time type that stores just a normal time (with no date
 
 Finally, container fields will come back as URI objects. You can:
 
-	- use Net::HTTP to download the contents of the container field using this URI
-	- to_s the URI and use it as the src attribute of an HTML image tag
-	- etc...
+  - use Net::HTTP to download the contents of the container field using this URI
+  - to_s the URI and use it as the src attribute of an HTML image tag
+  - etc...
 
 Specifically, the URI refers to the _contents_ of the container field. When accessed, the file, picture, or movie in the field will be downloaded.
 
@@ -632,13 +632,13 @@ When this is 'true' your script will dump the actual response it got from FileMa
 
 So, for an annoying, but detailed load of output, make a connection like this:
 
-	   my_server => Rfm::Server.new(
-	     :host             => 'myservername',
-	     :account_name     => 'user',
-	     :password         => 'pw',
-	     :log_actions      => true,
-	     :log_responses    => true
-	   )
+    my_server => Rfm::Server.new(
+      :host             => 'myservername',
+      :account_name     => 'user',
+      :password         => 'pw',
+      :log_actions      => true,
+      :log_responses    => true
+    )
 
 ### Source Code
 
@@ -678,8 +678,8 @@ See the changelog or the commit history for more details on changes in ginjo-rfm
 ### Version 2.1
 
 * Portals are now included by default.
-	Removed `:include_portals` query option in favor of `:ignore_portals`.
-	Added `:max_portal_rows` query option.
+  Removed `:include_portals` query option in favor of `:ignore_portals`.
+  Added `:max_portal_rows` query option.
 * Added field-remapping framework to allow model fields with different names than Filemaker fields.
 
         class User < Rfm::Base
@@ -716,21 +716,21 @@ See the changelog or the commit history for more details on changes in ginjo-rfm
 
 
 #### Data Modeling with ActiveModel
-	
+  
 If you can load ActiveModel in your project, you can have model callbacks, validations, and other ActiveModel features.
 If you can't load ActiveModel (because you're using something incompatible, like Rails 2),
 you can still use Rfm models... minus the ActiveModel-specific features like callbacks and validations. Rfm models give you basic
 data modeling with easy configuration and CRUD features.
 
-	  class User < Rfm::Base
-	    config      :layout=>'user_layout'
-	    before_save :encrypt_password
-	    validate    :valid_email_address
-	  end
-	
-	  @user = User.new :username => 'bill', :password => 'pass'
-	  @user.email = 'my@email.com'
-	  @user.save!
+    class User < Rfm::Base
+      config      :layout=>'user_layout'
+      before_save :encrypt_password
+      validate    :valid_email_address
+    end
+  
+    @user = User.new :username => 'bill', :password => 'pass'
+    @user.email = 'my@email.com'
+    @user.save!
 
 
 #### Choice of XML Parsers
@@ -741,31 +741,31 @@ Ginjo-rfm 2.0 uses ActiveSupport's XmlMini parsing interface, which has built-in
 LibXML, Nokogiri, and REXML. Additionally, ginjo-rfm includes adapters for Ox and Hpricot parsing.
 You can specifiy which parser to use or let Rfm decide.
 
-	  Rfm.config :parser => :libxml
+    Rfm.config :parser => :libxml
 
 If you're not able to install one of the faster parsers, ginjo-rfm will fall back to
 Ruby's built-in REXML. Want to roll your own XML adapter? Just pass it to Rfm as a module.
 
-	  Rfm.config :parser => MyHomeGrownAdapter
+    Rfm.config :parser => MyHomeGrownAdapter
 
 Choose your preferred parser globaly, as in the above example, or set a different parser for each model.
-		
-	  class Order < Rfm::Base
-	    config :parser => :hpricot
-	  end
-	
+    
+    class Order < Rfm::Base
+      config :parser => :hpricot
+    end
+  
 The current parsing options are
 
-	  :jdom         ->  JDOM (for JRuby)
-	  :oxsax        ->  Ox SAX
-	  :libxml       ->  LibXML Tree
-	  :libxmlsax    ->  LibXML SAX
-	  :nokogirisax  ->  Nokogiri SAX
-	  :nokogiri     ->  Nokogiri Tree
-	  :hpricot      ->  Hpricot Tree
-	  :rexml        ->  REXML Tree
-	  :rexmlsax     ->  REXML SAX
-	
+    :jdom         ->  JDOM (for JRuby)
+    :oxsax        ->  Ox SAX
+    :libxml       ->  LibXML Tree
+    :libxmlsax    ->  LibXML SAX
+    :nokogirisax  ->  Nokogiri SAX
+    :nokogiri     ->  Nokogiri Tree
+    :hpricot      ->  Hpricot Tree
+    :rexml        ->  REXML Tree
+    :rexmlsax     ->  REXML SAX
+  
 
 #### Configuration API
 
@@ -773,39 +773,39 @@ The ginjo-rfm configuration module lets you store your settings in several diffe
 
 rfm.yml
 
-	   :ssl: true
-	   :root_cert: false
-	   :timeout: 10
-	   :port: 443
-	   :host: live.mydomain.com
-	   :account_name: admin
-	   :password: pass
-	   :database: MyFmDb
+    :ssl: true
+    :root_cert: false
+    :timeout: 10
+    :port: 443
+    :host: live.mydomain.com
+    :account_name: admin
+    :password: pass
+    :database: MyFmDb
 
 Set a model's configuration.
-	
-	   class MyModel < Rfm::Base
-	     config :layout => 'mylayout'
-	   end
+  
+    class MyModel < Rfm::Base
+      config :layout => 'mylayout'
+    end
 
 
 #### Compound Filemaker Queries, with Omitable FMP Find Requests
 
 Create a Filemaker 'omit' request by including an :omit key with a value of true.
 
-	   my_layout.find :field1 => 'val1', :field2 => 'val2', :omit => true
+    my_layout.find :field1 => 'val1', :field2 => 'val2', :omit => true
 
 Create multiple Filemaker find requests by passing an array of hashes to the #find method.
 
-	   my_layout.find [{:field1 => 'bill', :field2 => 'admin'}, {:field2 => 'staff', :field3 => 'inactive', :omit => true}, ...]
+    my_layout.find [{:field1 => 'bill', :field2 => 'admin'}, {:field2 => 'staff', :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.
 
-	   my_layout.find :fieldOne => ['bill','mike','bob'], :fieldTwo =>'staff'
+    my_layout.find :fieldOne => ['bill','mike','bob'], :fieldTwo =>'staff'
 
 
 #### Full Metadata Support
-	
+  
 * Server databases
 * Database layouts
 * Database scripts
@@ -819,38 +819,38 @@ There are also many enhancements to make it easier to get the objects or data yo
 
 Get a database object using default config
 
-	  Rfm.db 'my_db'
+    Rfm.db 'my_db'
 
 Get a layout object using config grouping :my_group
-	
-	  Rfm.layout :my_group
+  
+    Rfm.layout :my_group
 
 Get the total count of all records in the table
 
-	  MyModel.total_count
+    MyModel.total_count
 
 Get the portal names (table-occurrence names) on the current layout
 
-	  MyModel.portal_names
+    MyModel.portal_names
 
 Get the names of fields on the current layout
 
-	  my_record.field_names
-	
-	
+    my_record.field_names
+  
+  
 ### From Version 1.4.x
 
 From ginjo-rfm 1.4.x, the following features are also included.
 
 Connection timeout settings
 
-	  Rfm.config :timeout => 10
+    Rfm.config :timeout => 10
 
 Value-list alternate display
 
-	   i = array_of_value_list_items[3]  # => '8765'
-	   i.value                           # => '8765'
-	   i.display                         # => '8765 Amy'
+    i = array_of_value_list_items[3]  # => '8765'
+    i.value                           # => '8765'
+    i.display                         # => '8765 Amy'