ginjo-rfm 3.0.9 → 3.0.10

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: d2a03d23cf578b34173f800b1658fe22465b2736
-  data.tar.gz: 02f0520fabc22fdaf653d02b1afa1b43867e65c9
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NzE0NWI5NTNjMDVhM2M0ZjZjMzI2Y2FiNDcyOGRiZmIxMGFlMmRiZQ==
+  data.tar.gz: !binary |-
+    MDY0MjgyNjJlYjM5NjBhNmVkYzFiN2NiMjI1ZWI3N2MzNzJiMDIxYQ==
 SHA512:
-  metadata.gz: fd1ad124d35792b2959dbb3a6f82d0534c303dee8686df59cdf963e255778e843b32cab896437b8e07082d65a2b2f43bd8a27bc4f9a825c15fad892ac0f16773
-  data.tar.gz: dd657b7d1a9fd7c4b85728da57e29fe6d480733bcf7d4ad65f32fbe34e3c6e033148d715198e8c84bb08985f30ef9a0dbce4f0bedcba9d0925b5676c56fad0e2
+  metadata.gz: !binary |-
+    NTcxNTk2YWQ2NzMwYjJmZDEwZWJmNjA3Nzc2MDIxNTBlMTc2OTY1ZjhkYmQx
+    MmU5ZjA3ZGU1MDY0NTY3NDlkNDA5YTc5MTNjNDNjZTdhZWY4NGQ2NmRmOTY1
+    OTMxNzkwZWVhZjkzZDhjOGViNGYyYjYzZDRmMTc3NzQyNmU2OTM=
+  data.tar.gz: !binary |-
+    MjY3MTNmYjBkNGU4YTE4ZTQ0MzA4YWU1NGQxYzY0NDdlZGIxOTQ2MGM4MGE2
+    Yjc2NTVlNDFhMjc5MzU4NDE3MGRlMjQ3NjFhMmY0Yzg1NjkwN2Q0YmJhMzky
+    YWEwZDg3ZTNhYzUwOWU2YWFkYTAwMWY4YTYxMmNjMTI5OTQwZDA=

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## Ginjo-Rfm 3.0.10
+
+* Fixed bug where missing metadata would cause errors when creating/editing records.
+
+* Added scoping support
+
+        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
+        Order.find({:user_id => '12345'})
+    
+        class Orders < Rfm::Base
+          SCOPE = Proc.new {|args| {:user_id => args} }
+        end
+        Order.find([{:status => ['open', 'processing']}, {:omit => true, :item_count => "<1"}], :scope_args => current_user.id)
+
+* Code cleanup
+
 ## Ginjo-Rfm 3.0.9
 
 * Fixed bug in parser that was appending each portal array recursively to itself.
@@ -14,20 +35,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
-		
+    
+        my_layout.find(12345).class  ==  Rfm::Record
+        MyModel.find(12345).class    ==  MyModel
+    
 
 ## Ginjo-Rfm 3.0.6
 
@@ -36,7 +57,7 @@
 
 ## Ginjo-Rfm 3.0.5
 
-* Fixed parser handling of `<field>` element that's missing a `<data>` element.
+* Fixed parser handling of ```<field>``` element that's missing a ```<data>``` element.
 * Fixed coercion of repeating field data.
 * Fixed case where special characters in Filemaker data yielded array instead of string (sax parsing split text).
 * Fixed various bugs in metadata parsing.
@@ -79,10 +100,10 @@
 * Record.new now automatically creats models based on layout name. Should there be an option to disable this?
 * Removed ActiveSupport requirement (of course, ActiveSupport will load if ActiveModle is used, but that is the users' choice).
 * Removed XmlMini, XmlParser, and related code & specs.
-*	Detached resultset from record, so record doesn't drag resultset around with it.
+* Detached resultset from record, so record doesn't drag resultset around with it.
 * Disabled automatic model creation from a table-name in a new Rfm::Record when initializing.
-*	Consolidated Base.new, Base#inititalize into Rfm::Record.
-*	Fixed validation callbacks issue.
+* Consolidated Base.new, Base#inititalize into Rfm::Record.
+* Fixed validation callbacks issue.
 * Fixed: Resultset will politely return [] when asked for non-existent portal\_names.
 * Mods to rakefile benchmarking/profiling.
 * Refactored Resultset metadata methods.
@@ -117,7 +138,7 @@
 ## Ginjo-Rfm 2.1.2
 
 * Fixed config.rb so that :file\_path (to user-defined yml config file) can be specified as a single path string
-	or as an array of path strings.
+  or as an array of path strings.
 
 ## Ginjo-Rfm 2.1.1
 
@@ -127,9 +148,9 @@
 
 ## Ginjo-Rfm 2.1.0
 
-* Removed `:include_portals` query option in favor of `:ignore_portals`.
+* Removed ```:include_portals``` query option in favor of ```:ignore_portals```.
 
-* Added `:max_portal_rows` query option.
+* Added ```:max_portal_rows``` query option.
 
 * Added field-remapping framework to allow model fields with different names than Filemaker fields.
 
@@ -138,11 +159,11 @@
 * Detached new Server objects from Factory.servers hash, so wont reuse or stack-up servers.
 
 * 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).
-	
+  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`.
+* Configuration ```:use``` option now works for all Rfm objects that respond to ```config```.
 
 ## Ginjo-Rfm 2.0.2
 
@@ -192,47 +213,47 @@
 
 * Re-implemented:  
   
-	Layout#field\_controls
+  Layout#field\_controls
 
-	Layout#value\_lists  
+  Layout#value\_lists  
   
 * Enhanced:  
 
-	ValueListItem handles both display & data items now.
+  ValueListItem handles both display & data items now.
 
-	Timeout feature from timting (github/timting/rfm).
+  Timeout feature from timting (github/timting/rfm).
 
-	Added specs for Record#save.  
+  Added specs for Record#save.  
   
 * Fixed:  
 
-	[Bug] Getting & setting fields with symbol-based keys was producing error.
+  [Bug] Getting & setting fields with symbol-based keys was producing error.
 
-	[Bug] Setting fields would not update main record hash.
+  [Bug] Setting fields would not update main record hash.
 
-	[Bug] Record#save wasn't merging back into self.  
+  [Bug] Record#save wasn't merging back into self.  
 
 * Partial Fix:  
 
-	server.db.all
-	db.layout.all
-	db.script.all  
+  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.  
+  Note: the "#all" method returns object names (as keys) only. The receiver of the method maintains the full object collection.  
 
-	Example:  
+  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:
+  Example:
  
-		Old: record.john #=> "" 
-		New: record.john #=> nil
+        Old: record.john #=> "" 
+        New: record.john #=> nil
    
 ## Lardawge-Rfm 1.4.1.2
 
@@ -252,13 +273,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:  
+  Example:  
   
-		result = fm_server('layout').find({:username => "==#{username}"}, {:include_portals => true})
-		# => This will fetch all records with portal records attached.
+        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.
+        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.
 

data/README.md

@@ -24,12 +24,12 @@ Ginjo-rfm version 3 has been tested successfully on Ruby 1.8.7 thru 2.1.3.
 
 ## Documentation & Links
 
-* Ginjo-rfm rubygem   <https://rubygems.org/gems/ginjo-rfm>
-* Rdoc location       <http://rubydoc.info/github/ginjo/rfm/frames>
+* Gem                 <https://rubygems.org/gems/ginjo-rfm>
+* Rdoc                <http://rubydoc.info/github/ginjo/rfm>
+* Github              <https://github.com/ginjo/rfm>
 * Discussion          <http://groups.google.com/group/rfmcommunity>
-* Ginjo at github     <https://github.com/ginjo/rfm>
-* Original homepage   <http://sixfriedrice.com/wp/products/rfm/>
-* Lardawge at github  <https://github.com/lardawge/rfm>
+* Original            <http://sixfriedrice.com/wp/products/rfm/>
+* Lardawge            <https://github.com/lardawge/rfm>
 
 ## Requirements
 
@@ -183,7 +183,7 @@ You can also include or extend the Rfm::Config module in any object in your proj
 	     # 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 heirarchy 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.
+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
 	
@@ -512,7 +512,7 @@ All of these methods return an Rfm::Resultset object (see below), and every one
 
 	   my_layout.find({:state => "AZ"}, {:max_records => 10, :skip_records => 100})
 
-For a complete list of the available options, see the "expand_options" method in the Rfm::Server object in the file named server.rb.
+For a complete list of the available options, see the "Common Options" section in the layout.rb file.
 
 Finally, if filemaker returns an error when executing any of these methods, an error will be raised in your Ruby script. There is one exception to this, though. If a find results in no records being found (FileMaker error # 401) I just ignore it and return you a Resultset with zero records in it. If you prefer an error in this case, add :raise_on_401 => true to the options you pass the Rfm::Server when you create it.
 
@@ -864,6 +864,6 @@ Other lead contributors:
 * Atsushi Matsuo was an early Rfm tester, and provided outstanding feedback, critical code fixes, and a lot of web exposure.
 * Jesse Antunes helped ensure that Rfm is stable and functional.
 * Larry Sprock added ssl support, switched the xml parser to a much faster Nokogiri, added the rspec testing framework, and refined code architecture.
-* William Richardson is the current maintainer of the ginjo-rfm fork and added support for multiple xml parsers, ActiveModel integration, field mapping, compound queries, logging, and a configuration framework.
+* William Richardson is the current maintainer of the ginjo-rfm fork and added support for multiple xml parsers, ActiveModel integration, field mapping, compound queries, logging, scoping, and a configuration framework.
 
 

data/lib/rfm.rb

@@ -1,6 +1,6 @@
 module Rfm
-	PATH = File.expand_path(File.dirname(__FILE__))
-	$LOAD_PATH.unshift(PATH) unless $LOAD_PATH.include?(PATH)
+  PATH = File.expand_path(File.dirname(__FILE__))
+  $LOAD_PATH.unshift(PATH) unless $LOAD_PATH.include?(PATH)
 end
 
 #require 'thread' # some versions of ActiveSupport will raise error about Mutex unless 'thread' is loaded.
@@ -10,7 +10,7 @@ require 'rfm/utilities/core_ext'
 require 'rfm/utilities/case_insensitive_hash'
 
 module Rfm
-  
+
   class CommunicationError  < StandardError; end
   class ParameterError      < StandardError; end
   class AuthenticationError < StandardError; end
@@ -28,18 +28,19 @@ module Rfm
   autoload :CompoundQuery,'rfm/utilities/compound_query'
   autoload :VERSION,      'rfm/version'
   autoload :Connection,   'rfm/utilities/connection.rb'
+  autoload :Scope,        'rfm/utilities/scope.rb'
+
+  module Metadata
+    autoload :Script,         'rfm/metadata/script'
+    autoload :Field,          'rfm/metadata/field'
+    autoload :FieldControl,   'rfm/metadata/field_control'
+    autoload :ValueListItem,  'rfm/metadata/value_list_item'
+    autoload :Datum,          'rfm/metadata/datum'
+    autoload :ResultsetMeta,  'rfm/metadata/resultset_meta'
+    autoload :LayoutMeta,     'rfm/metadata/layout_meta'
+  end
 
-	module Metadata
-		autoload :Script,         'rfm/metadata/script'
-		autoload :Field,          'rfm/metadata/field'
-		autoload :FieldControl,   'rfm/metadata/field_control'
-		autoload :ValueListItem,  'rfm/metadata/value_list_item'
-		autoload :Datum,  				'rfm/metadata/datum'
-		autoload :ResultsetMeta,  'rfm/metadata/resultset_meta'
-		autoload :LayoutMeta,     'rfm/metadata/layout_meta'
-	end
-
-	def info
+  def info
     rslt = <<-EEOOFF
       Gem name: ginjo-rfm
       Version: #{VERSION}
@@ -51,57 +52,55 @@ module Rfm
     rslt.gsub!(/^[ \t]*/, '')
     rslt
   rescue
-  	"Could not retrieve info: #{$!}"
-	end
-	
-	def info_short
-		"Using ginjo-rfm version #{::Rfm::VERSION} with #{SaxParser::Handler.get_backend}"
-	end
-	
-	def_delegators 'Rfm::Factory', :servers, :server, :db, :database, :layout
-	def_delegators 'Rfm::Config', :config, :get_config, :config_clear
-	def_delegators 'Rfm::Resultset', :load_data
-	
-	def models(*args)
-		Rfm::Base
-		Rfm::Factory.models(*args)
-	end
-	
-	def modelize(*args)
-		Rfm::Base
-		Rfm::Factory.modelize(*args)
-	end
-		
-	def logger
-		@@logger ||= get_config[:logger] || Logger.new(STDOUT).tap {|l| l.formatter = proc {|severity, datetime, progname, msg| "#{datetime}: Rfm-#{severity} #{msg}\n"}}
-	end
-	
-	alias_method :log, :logger
-	
-	def logger=(obj)
-		@@logger = obj
-	end
-	
-	# 	DEFAULT_CLASS = CaseInsensitiveHash
-	# 	TEMPLATE_PREFIX = File.join(File.dirname(__FILE__), 'rfm/utilities/sax/')
-	# 	TEMPLATES = {
-	# 		:fmpxmllayout => 'fmpxmllayout.yml',
-	# 		:fmresultset => 'fmresultset.yml',
-	# 		:fmpxmlresult => 'fmpxmlresult.yml',
-	# 		:none => nil
-	# 	}
-	
-	PARSER_DEFAULTS = {
-		:default_class => CaseInsensitiveHash,
-		:template_prefix => File.join(File.dirname(__FILE__), 'rfm/utilities/sax/'),
-		:templates => {
-			:fmpxmllayout => 'fmpxmllayout.yml',
-			:fmresultset => 'fmresultset.yml',
-			:fmpxmlresult => 'fmpxmlresult.yml',
-			:none => nil
-		}
-	}	
-	
-	extend self
-	
+    "Could not retrieve info: #{$!}"
+  end
+
+  def info_short
+    "Using ginjo-rfm version #{::Rfm::VERSION} with #{SaxParser::Handler.get_backend}"
+  end
+
+  def_delegators 'Rfm::Factory', :servers, :server, :db, :database, :layout
+  def_delegators 'Rfm::Config', :config, :get_config, :config_clear
+  def_delegators 'Rfm::Resultset', :load_data
+
+  def models(*args)
+    Rfm::Factory.models(*args)
+  end
+
+  def modelize(*args)
+    Rfm::Factory.modelize(*args)
+  end
+
+  def logger
+    @@logger ||= get_config[:logger] || Logger.new(STDOUT).tap {|l| l.formatter = proc {|severity, datetime, progname, msg| "#{datetime}: Rfm-#{severity} #{msg}\n"}}
+  end
+
+  alias_method :log, :logger
+
+  def logger=(obj)
+    @@logger = obj
+  end
+
+  # DEFAULT_CLASS = CaseInsensitiveHash
+  # TEMPLATE_PREFIX = File.join(File.dirname(__FILE__), 'rfm/utilities/sax/')
+  # TEMPLATES = {
+  #   :fmpxmllayout => 'fmpxmllayout.yml',
+  #   :fmresultset => 'fmresultset.yml',
+  #   :fmpxmlresult => 'fmpxmlresult.yml',
+  #   :none => nil
+  # }
+
+  PARSER_DEFAULTS = {
+    :default_class => CaseInsensitiveHash,
+    :template_prefix => File.join(File.dirname(__FILE__), 'rfm/utilities/sax/'),
+    :templates => {
+      :fmpxmllayout => 'fmpxmllayout.yml',
+      :fmresultset => 'fmresultset.yml',
+      :fmpxmlresult => 'fmpxmlresult.yml',
+      :none => nil
+    }
+  }
+
+  extend self
+
 end # Rfm

data/lib/rfm/VERSION

@@ -1 +1 @@
-3.0.9
+3.0.10

data/lib/rfm/base.rb

@@ -1,201 +1,197 @@
 module Rfm
-	#
-	# Adds ability to create Rfm::Base model classes that behave similar to ActiveRecord::Base models.
-	# If you set your Rfm.config (or RFM_CONFIG) with your host, database, account, password, and
-	# any other server/database options, you can provide your models with nothing more than a layout.
-	#
-	# 	class Person < Rfm::Base
-	# 	  config :layout => 'mylayout'
-	# 	end
-	#
-	# And similar to ActiveRecord, you can define callbacks, validations, attributes, and methods on your model.
-	#   (if you have ActiveModel loaded).
-	#
-	#   class Account < Rfm::Base
-	#     config :layout=>'account_xml'
-	#     before_create :encrypt_password
-	#     validates :email, :presence => true
-	#     validates :username, :presence => true
-	#     attr_accessor :password
-	#   end
-	#   
-	# Then in your project, you can use these models just like ActiveRecord models.
-	# The query syntax and options are still Rfm under the hood. Treat your model
-	# classes like Rfm::Layout objects, with a few enhancements.
-	#
-	#   @account = Account.new :username => 'bill', :password => 'pass'
-	#   @account.email = 'my@email.com'
-	#   @account.save!
-	#   
-	#   @person = Person.find({:name => 'mike'}, :max_records => 50)[0]
-	#   @person.update_attributes(:name => 'Michael', :title => "Senior Partner")
-	#   @person.save
-	#
+
+  # Adds ability to create Rfm::Base model classes that behave similar to ActiveRecord::Base models.
+  # If you set your Rfm.config (or RFM_CONFIG) with your host, database, account, password, and
+  # any other server/database options, you can provide your models with nothing more than a layout.
+  #
+  #   class Person < Rfm::Base
+  #     config :layout => 'mylayout'
+  #   end
+  #
+  # And similar to ActiveRecord, you can define callbacks, validations, attributes, and methods on your model.
+  #   (if you have ActiveModel loaded).
+  #
+  #   class Account < Rfm::Base
+  #     config :layout=>'account_xml'
+  #     before_create :encrypt_password
+  #     validates :email, :presence => true
+  #     validates :username, :presence => true
+  #     attr_accessor :password
+  #   end
+  #
+  # Then in your project, you can use these models just like ActiveRecord models.
+  # The query syntax and options are still Rfm under the hood. Treat your model
+  # classes like Rfm::Layout objects, with a few enhancements.
+  #
+  #   @account = Account.new :username => 'bill', :password => 'pass'
+  #   @account.email = 'my@email.com'
+  #   @account.save!
+  #
+  #   @person = Person.find({:name => 'mike'}, :max_records => 50)[0]
+  #   @person.update_attributes(:name => 'Michael', :title => "Senior Partner")
+  #   @person.save
+
   class Base <  Rfm::Record  #Hash
     extend Config
     config :parent => 'Rfm::Config'
-    
+
     begin
-    	require 'active_model'
+      require 'active_model'
       include ActiveModel::Validations
       include ActiveModel::Serialization
       extend ActiveModel::Callbacks
       include ActiveModel::Validations::Callbacks
       define_model_callbacks(:create, :update, :destroy)
     rescue LoadError, StandardError
-    	def run_callbacks(*args)
-    		yield
-    	end
+      def run_callbacks(*args)
+        yield
+      end
     end
-		
+
     def to_partial_path(object = self) #@object)
-    	return 'some/partial/path'
-    	##### DISABLED HERE - ActiveModel Lint only needs a string #####
-    	##### TODO: implement to_partial_path to return meaningful string.
-      @partial_names[object.class.name] ||= begin
-        object = object.to_model if object.respond_to?(:to_model)
-
-        object.class.model_name.partial_path.dup.tap do |partial|
-          path = @view.controller_path
-          partial.insert(0, "#{File.dirname(path)}/") if partial.include?(?/) && path.include?(?/)
+      return 'some/partial/path'
+      ##### DISABLED HERE - ActiveModel Lint only needs a string #####
+      ##### TODO: implement to_partial_path to return meaningful string.
+      # @partial_names[object.class.name] ||= begin
+      #   object = object.to_model if object.respond_to?(:to_model)
+
+      #   object.class.model_name.partial_path.dup.tap do |partial|
+      #     path = @view.controller_path
+      #     partial.insert(0, "#{File.dirname(path)}/") if partial.include?(?/) && path.include?(?/)
+      #   end
+      # end
+    end
+
+    class << self
+
+      # 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, :count, :ignore_bad_data
+
+      def inherited(model)
+        (Rfm::Factory.models << model).uniq unless Rfm::Factory.models.include? model
+        model.config :parent=>'Rfm::Base'
+      end
+
+      def config(*args)
+        super(*args){|options| @config.merge!(:layout=>options[:strings][0]) if options[:strings] && options[:strings][0]}
+      end
+
+      # Access/create the layout object associated with this model
+      def layout
+        return @layout if @layout
+        #         cnf = get_config
+        #         raise "Could not get :layout from get_config in Base.layout method" unless cnf[:layout] #return unless cnf[:layout]
+        #         @layout = Rfm::Factory.layout(cnf).sublayout
+        name = get_config[:layout] || 'test'   # The 'test' was added to help active-model-lint tests pass.
+        @layout = Rfm::Factory.layout(name, self) #.sublayout
+
+        # Added by wbr to give config hierarchy: layout -> model -> sublayout
+        #config :parent=>'parent_layout'
+        #config :parent=>'Rfm::Config'
+        #@layout.config model
+        #@layout.config :parent=>self
+
+        @layout.model = self
+        @layout
+      end
+
+      #       # Access the parent layout of this model
+      #       def parent_layout
+      #         layout #.parent_layout
+      #       end
+
+      # Just like Layout#find, but searching by record_id will return a record, not a resultset.
+      def find(find_criteria, options={})
+        #puts "base.find-#{layout.object_id}"
+        r = layout.find(find_criteria, options)
+        if ![Hash,Array].include?(find_criteria.class) and r.size == 1
+          r[0]
+        else
+          r
         end
+      rescue Rfm::Error::RecordMissingError
+        nil
+      end
+
+      # Layout#any, returns single record, not resultset
+      def any(*args)
+        layout.any(*args)[0]
+      end
+
+      # New record, save, (with callbacks & validations if ActiveModel is loaded)
+      def create(*args)
+        new(*args).send :create
+      end
+
+      # Using this method will skip callbacks. Use instance method +#update+ instead
+      def edit(*args)
+        layout.edit(*args)[0]
       end
+
+    end # class << self
+
+
+    # Is this a newly created record, not saved yet?
+    def new_record?
+      return true if (self.record_id.nil? || self.record_id.empty?)
     end
-		
-		class << self
-		
-	    # 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, :count, :ignore_bad_data
-
-			def inherited(model)
-				(Rfm::Factory.models << model).uniq unless Rfm::Factory.models.include? model
-				model.config :parent=>'Rfm::Base'
-			end
-		  
-	    def config(*args)
-	    	super(*args){|options| @config.merge!(:layout=>options[:strings][0]) if options[:strings] && options[:strings][0]}
-	    end
-		  		  			
-			# Access/create the layout object associated with this model
-	  	def layout
-	  		return @layout if @layout
-# 	  		cnf = get_config
-# 	  		raise "Could not get :layout from get_config in Base.layout method" unless cnf[:layout] #return unless cnf[:layout]
-# 	  		@layout = Rfm::Factory.layout(cnf).sublayout
-				name = get_config[:layout] || 'test'   # The 'test' was added to help active-model-lint tests pass.
-				@layout = Rfm::Factory.layout(name, self) #.sublayout
-	  		
-	  		# Added by wbr to give config heirarchy: layout -> model -> sublayout
-	  		#config :parent=>'parent_layout'
-	  		#config :parent=>'Rfm::Config'
-	  		#@layout.config model
-	  		#@layout.config :parent=>self
-	  		
-				@layout.model = self
-				@layout
-	  	end
-	  	
-# 	  	# Access the parent layout of this model
-# 	  	def parent_layout
-# 	  		layout #.parent_layout
-# 	  	end
-		  			
-			# Just like Layout#find, but searching by record_id will return a record, not a resultset.
-	  	def find(find_criteria, options={})
-	  		#puts "base.find-#{layout.object_id}"
-	  	  r = layout.find(find_criteria, options)
-	  	  if ![Hash,Array].include?(find_criteria.class) and r.size == 1
-	  	    r[0]
-		    else
-		      r
-	      end
-	    rescue Rfm::Error::RecordMissingError
-	      nil
-	  	end
-
-			# Layout#any, returns single record, not resultset
-	  	def any(*args)
-	  	  layout.any(*args)[0]
-	  	end
-
-			# New record, save, (with callbacks & validations if ActiveModel is loaded)
-	  	def create(*args)
-	  	  new(*args).send :create
-	  	end
-	  		  
-	    # Using this method will skip callbacks. Use instance method +#update+ instead
-		  def edit(*args)
-		    layout.edit(*args)[0]
-	    end
-	    
-		end # class << self
-
-
-		
-		
-
-		
-		# Is this a newly created record, not saved yet?					
-  	def new_record?
-  		return true if (self.record_id.nil? || self.record_id.empty?)
-  	end
-
-		# Reload record from database
-		# TODO: handle error when record has been deleted
-		# TODO: Move this to Rfm::Record.
-		def reload(force=false)
-	    if (@mods.empty? or force) and record_id
-	    	@mods.clear
-	      self.replace_with_fresh_data layout.find(self.record_id)[0]   #self.class.find(self.record_id)
+
+    # Reload record from database
+    # TODO: handle error when record has been deleted
+    # TODO: Move this to Rfm::Record.
+    def reload(force=false)
+      if (@mods.empty? or force) and record_id
+        @mods.clear
+        self.replace_with_fresh_data layout.find(self.record_id)[0]   #self.class.find(self.record_id)
       end
     end
-    
+
     # Mass update of record attributes, without saving.
     def update_attributes(new_attr)
-    	new_attr.each do |k,v|
-    		k = k.to_s.downcase
-    		if keys.include?(k)
-    			@mods[k] = v
-    			self[k] = v
-    		else
-    			instance_variable_set("@#{k}", v)
-    		end
-    	end
+      new_attr.each do |k,v|
+        k = k.to_s.downcase
+        if keys.include?(k)
+          @mods[k] = v
+          self[k] = v
+        else
+          instance_variable_set("@#{k}", v)
+        end
+      end
     end
-		#     # Mass update of record attributes, without saving.
-		#     # TODO: return error or nil if input hash contains no recognizable keys.
-		#     def update_attributes(new_attr)
-		#       # creates new special hash
-		#       input_hash = Rfm::CaseInsensitiveHash.new
-		#       # populate new hash with input, coercing keys to strings
-		#       #new_attr.each{|k,v| input_hash.merge! k.to_s=>v}
-		#       new_attr.each{|k,v| input_hash[k.to_s] = v}
-		#       # loop thru each layout field, adding data to @mods
-		#       self.class.field_controls.keys.each do |field| 
-		#         field_name = field.to_s
-		#         if input_hash.has_key?(field_name)
-		#           #@mods.merge! field_name=>(input_hash[field_name] || '')
-		#           @mods[field_name] = (input_hash[field_name] || '')
-		#         end
-		#       end
-		#       # loop thru each input key-value,
-		#       # creating new attribute if key doesn't exist in model.
-		#       input_hash.each do |k,v| 
-		#         if !self.class.field_controls.keys.include?(k) and self.respond_to?(k)
-		#           self.instance_variable_set("@#{k}", v)
-		#         end
-		#       end            
-		#       self.merge!(@mods) unless @mods == {}
-		#       #self.merge!(@mods) unless @mods == Rfm::CaseInsensitiveHash.new
-		#     end
-    
+    #     # Mass update of record attributes, without saving.
+    #     # TODO: return error or nil if input hash contains no recognizable keys.
+    #     def update_attributes(new_attr)
+    #       # creates new special hash
+    #       input_hash = Rfm::CaseInsensitiveHash.new
+    #       # populate new hash with input, coercing keys to strings
+    #       #new_attr.each{|k,v| input_hash.merge! k.to_s=>v}
+    #       new_attr.each{|k,v| input_hash[k.to_s] = v}
+    #       # loop thru each layout field, adding data to @mods
+    #       self.class.field_controls.keys.each do |field| 
+    #         field_name = field.to_s
+    #         if input_hash.has_key?(field_name)
+    #           #@mods.merge! field_name=>(input_hash[field_name] || '')
+    #           @mods[field_name] = (input_hash[field_name] || '')
+    #         end
+    #       end
+    #       # loop thru each input key-value,
+    #       # creating new attribute if key doesn't exist in model.
+    #       input_hash.each do |k,v| 
+    #         if !self.class.field_controls.keys.include?(k) and self.respond_to?(k)
+    #           self.instance_variable_set("@#{k}", v)
+    #         end
+    #       end
+    #       self.merge!(@mods) unless @mods == {}
+    #       #self.merge!(@mods) unless @mods == Rfm::CaseInsensitiveHash.new
+    #     end
+
     # Mass update of record attributes, with saving.
     def update_attributes!(new_attr)
       self.update_attributes(new_attr)
       self.save!
     end
-    
+
     # Save record modifications to database (with callbacks & validations). If record cannot be saved will raise error.
     def save!
       #return unless @mods.size > 0
@@ -206,95 +202,95 @@ module Rfm
         self.create
       end
     end
-    
-	  # Same as save!, but will not raise error.
+
+    # Same as save!, but will not raise error.
     def save
       save!
     rescue
       (self.errors[:base] rescue []) << $!
       return nil
     end
-	  
-		# Just like Layout#save_if_not_modified, but with callbacks & validations.
+
+    # Just like Layout#save_if_not_modified, but with callbacks & validations.
     def save_if_not_modified
       update(@mod_id) if @mods.size > 0
-    end    
-    
+    end
+
     # Delete record from database, with callbacks & validations.
-  	def destroy
-  	  return unless record_id
-  	  run_callbacks :destroy do
-  	    self.class.delete(record_id)
-  	    @destroyed = true
-  	    @mods.clear
-	    end
-	    self.freeze
-  	  #self
-	  end
-	  
-	  def destroyed?
-	  	@destroyed
-	  end
-	  
-		# For ActiveModel compatibility
-		def to_model
-			self
-		end
-		
-		def persisted?
-			record_id ? true : false
-		end
-		
-		def to_key
-			record_id ? [record_id] : nil
-		end
-		
-		def to_param
-			record_id
-		end
-    
-	
-  protected # Base
-  
-  	def self.create_from_new(*args)
-  	  layout.create(*args)[0]
-  	end
-  
+    def destroy
+      return unless record_id
+      run_callbacks :destroy do
+        self.class.delete(record_id)
+        @destroyed = true
+        @mods.clear
+      end
+      self.freeze
+      #self
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    # For ActiveModel compatibility
+    def to_model
+      self
+    end
+
+    def persisted?
+      record_id ? true : false
+    end
+
+    def to_key
+      record_id ? [record_id] : nil
+    end
+
+    def to_param
+      record_id
+    end
+
+
+    protected # Base
+
+    def self.create_from_new(*args)
+      layout.create(*args)[0]
+    end
+
     # shunt for callbacks when not using ActiveModel
     def callback_deadend (*args)
       yield  #(*args)
     end
-    
+
     def create
       raise "Record not valid" if (defined?(ActiveModel::Validations) && !valid?)
       run_callbacks :create do
         return unless @mods.size > 0
-  	    # merge_rfm_result self.class.create_from_new(@mods)
-  	    replace_with_fresh_data self.class.create_from_new(@mods)
-  	  end
-  	  self
-  	end
-  	
+        # merge_rfm_result self.class.create_from_new(@mods)
+        replace_with_fresh_data self.class.create_from_new(@mods)
+      end
+      self
+    end
+
     def update(mod_id=nil)
       raise "Record not valid" if (defined?(ActiveModel::Validations) && !valid?)
       return false unless record_id 
-  	  run_callbacks :update do
-  	    return unless @mods.size > 0
-  	    unless mod_id
-  	      # regular save
-  	      # merge_rfm_result self.class.send :edit, record_id, @mods
-  	      replace_with_fresh_data self.class.send :edit, record_id, @mods
-	      else
-	        # save_if_not_modified
-	        # merge_rfm_result self.class.send :edit, record_id, @mods, :modification_id=>mod_id
-	        replace_with_fresh_data self.class.send :edit, record_id, @mods, :modification_id=>mod_id
+      run_callbacks :update do
+        return unless @mods.size > 0
+        unless mod_id
+          # regular save
+          # merge_rfm_result self.class.send :edit, record_id, @mods
+          replace_with_fresh_data self.class.send :edit, record_id, @mods
+        else
+          # save_if_not_modified
+          # merge_rfm_result self.class.send :edit, record_id, @mods, :modification_id=>mod_id
+          replace_with_fresh_data self.class.send :edit, record_id, @mods, :modification_id=>mod_id
         end
-  	  end
-  	  self
-  	end
-  	
-  	# Deprecated in favor of Record#replace_with_fresh_data
-  	def merge_rfm_result(result_record)
+      end
+      self
+    end
+
+    # Deprecated in favor of Record#replace_with_fresh_data
+    def merge_rfm_result(result_record)
       return unless @mods.size > 0
       @record_id ||= result_record.record_id
       self.merge! result_record
@@ -302,7 +298,7 @@ module Rfm
       self || {}
       #self || Rfm::CaseInsensitiveHash.new
     end
-    
+
   end # Base
 
 end # Rfm