require 'app/configuration'module RubyAMF  module Configuration    #set the service path used in all requests    RubyAMF::App::RequestStore.service_path = File.expand_path(RAILS_ROOT) + '/app/controllers'    #=> CLASS MAPPING CONFIGURATION    #    # 'path' defines the search location for incoming custom class that aren't of type active_record.    # For example, if you defined a class as [RemoteClass(alias="vo.MyVO")], there should be a ruby    # file in app/vo/MyVO.rb. The path is defined like so:  RAILS_ROOT + vo_path + remote_class_package    # This only matters if you're using VO's that aren't of type active_record    ClassMappings.path = 'app'        #=> FLEX DATE CONVERSION    # Specify if you want to use DateTime instead of Time for converting Flex Date Data Types    ClassMappings.use_ruby_date_time = false    #=> USE ARRAY COLLECTION    # By setting this to true, you opt in to using array collections for all the arrays generated by the body of your request.    # Note: This only works for amf3 with Remote Object, NOT with Net Connection.    ClassMappings.use_array_collection = false        #=>CHECK FOR ASSOCIATIONS    # If you do no specify the associations you want to load in the ClassMappings, then set this to true if you want    # RubyAMF to pick up eager-loaded associations. For large active record collections, it is suggested not to use this     # feature, but rather to specify the specific associations you would like loaded.    ClassMappings.check_for_associations = true          #=> GLOBAL PROPERTY IGNORING    # By putting attribute names into this array, you opt in to globally ignore these properties on incoming objects.    # If you want to ignore specific properties on certain objects, use the :ignore_fields property in a     # Class Mapping definition (see CLASS MAPPING DEFINITIONS)    ClassMappings.ignore_fields = ['created_at','created_on','updated_at','updated_on']        #=> CLASS MAPPING DEFINITIONS    # A Class Mapping definition conists of at least these two properties:    # :actionscript   # The incoming action script class to watch for    # :ruby           # The ruby class to turn it into    #    #=> Optional value object properties:    # :type                 # Used to spectify the type of VO, valid options are 'active_record', 'custom',  (or don't specify at all)    # :associations     # Specify which associations to read on the active record (only applies to active records)    # :attributes        # Specifically which attributes to include in the serialization    # :ignore_fields  # An array of field names you want to ignore on incoming classes    #    # If you are using ActiveRecord VO's you do not need to specify a fully qualified class path to the model, you can just define the class name,     # EX: ClassMappings.register(:actionscript => 'vo.Person', :ruby => 'Person', :type => 'active_record')    #    # If you are using custom VO's you would need to specify the fully qualified class path to the file    # EX: ClassMappings.register(:actionscript => 'vo.Person', :ruby => 'org.mypackage.Person')    #    #ClassMappings.register(:actionscript => 'Person', :ruby => 'Person', :type => 'active_record', :attributes => ["id", "address_id"])    #ClassMappings.register(:actionscript => 'User', :ruby => 'User', :type => 'active_record', :associations=> ["addresses", "credit_cards"])    #ClassMappings.register(:actionscript => 'Address', :ruby => 'Address', :type => 'active_record')    #    # CLASS MAPPING SCOPE (ADVANCED USAGE)    # You can also specify a class mapping scope if you want. For example, lets say you need certain attributes for a book when you are viewing a book    # in flex as opposed to editing a book (where you would need more parameters). You can define a scope mapping parameter for ":attributes"    # or for ":associations." You're mapping would look something like this.    # ClassMappings.register(    #  :actionscript  => 'com.mixbook.vo.books.BookVO',          #   :ruby          => 'Book',          #   :type          => 'active_record',    #   :associations  => ["access_info", "pages", "page_ratio"],      #   :attributes    => {:viewing => ["description", "title"], :editing => ["id","published_at","theme_id"] }    <=== notice the hash instead of an array    #    # Now, to call the class mapping scope of editing (you are sending objects to the editing application), your controller call would look like this:    # EX: render :amf => book, :class_mapping_scope => :editing    #    # You can also specify a default scope to use. If you don't set this and you don't specify a class mapping scope on an attribute or association, then     # it will not have a scope to use and will not add any attributes or associations (whichever it cant match) to that association.    # ClassMappings.default_mapping_scope = :viewing        #=> FORCE ACTIVE RECORD IDS    # includes the id field for activerecord objects even if you don't specify it when using custom attributes. This is important for deserialization    # where ids are needed to keep active record association integrity.    ClassMappings.force_active_record_ids = true         #=> CASE TRANSLATIONS    # Most actionscript uses camelCase instead of snake_case. Set ClassMappings.translate_case to true if want translations to occur.    # The translations only occur on object properties    # An incoming property like: myProperty gets turned into my_property    # An outgoing property like my_property gets turned into myProperty    ClassMappings.translate_case = false        #=> RETURN TOP LEVEL HASH    # For those scaffolding users out there, who want the top-level object to come as a hash so scaffolding works out of the box.    ParameterMappings.scaffolding = false        #=> INCOMING REMOTING PARAMETER MAPPINGS    # Incoming Remoting Parameter mappings allow you to map an incoming requests parameters into rails' params hash    #    # Here's an example:    # ParameterMappings.register(    #   :controller => :UserController,    #   :action => :find_friend,    #   :params => { :friend => "[0].friend" }    # )    #     # That example maps the first remoting parameters "friend" property into params[:friend]    #    # [0] represents an array accessor    # . represents object notation.    # So you could do this: "[0][0].users[5].firstname" and it will take the value    # from your remoting parameters: [0][0].users[5].firstname    #     # Also, you can have it apply globally to an entire controller, just leave out the action key    #    # Here's an example:    # ParameterMappings.register(    #   :controller => :UserController,    #   :params => { :friend => "[0].friend" }    # )    # Now, everything going to the UserController will convert the first remoting parameters friend property     # to friend in EVERY ACTION  endend