# File lib/model/base.rb, line 43
      def to_record(*params)
        fieldset, options = Util.extract_fieldset_and_options params
        
        fields = []
        if options[:fields].empty?
          fields = self.class.extjs_get_fields_for_fieldset(fieldset)
        else
          fields = self.class.process_fields(*options[:fields])
        end
        
        assns   = self.class.extjs_associations
        pk      = self.class.extjs_primary_key
        
        # build the initial field data-hash
        data    = {pk => self.send(pk)}
         
        fields.each do |field|
          next if data.has_key? field[:name] # already processed (e.g. explicit mentioning of :id)
          
          value = nil
          if association_reflection = assns[field[:name]] # if field is an association
            association = self.send(field[:name])
            
            # skip this association if we already visited it
            # otherwise we could end up in a cyclic reference
            next if options[:visited_classes].include? association.class
            
            case association_reflection[:type]
            when :belongs_to, :has_one
              if association.respond_to? :to_record
                assn_fields = field[:fields]
                if assn_fields.nil?
                  assn_fields = association.class.extjs_get_fields_for_fieldset(field.fetch(:fieldset, fieldset))
                end
                
                value = association.to_record :fields => assn_fields,
                  :visited_classes => options[:visited_classes] + [self.class]
              else
                value = {}
                (field[:fields]||[]).each do |sub_field|
                  value[sub_field[:name]] = association.send(sub_field[:name]) if association.respond_to? sub_field[:name]
                end
              end
              if association_reflection[:type] == :belongs_to
                # Append associations foreign_key to data
                data[association_reflection[:foreign_key]] = self.send(association_reflection[:foreign_key])
                if association_reflection[:is_polymorphic]
                  foreign_type = self.class.extjs_polymorphic_type(association_reflection[:foreign_key])
                  data[foreign_type] = self.send(foreign_type)
                end
              end
            when :many
              value = association.collect { |r| r.to_record }  # use carefully, can get HUGE
            end
          else # not an association -> get the method's value
            value = self.send(field[:name])
            value = value.to_record if value.respond_to? :to_record
          end
          data[field[:name]] = value
        end
        data
      end