# File lib/model/base.rb, line 133
      def extjs_record(*params)
        fieldset, options = Util.extract_fieldset_and_options params
        
        if options[:fields].empty?
          fields = self.extjs_get_fields_for_fieldset(fieldset)
        else
          fields = self.process_fields(*options[:fields])
        end
        
        associations  = self.extjs_associations
        columns       = self.extjs_columns_hash
        pk            = self.extjs_primary_key
        rs            = []
        
        fields.each do |field|

          field = Marshal.load(Marshal.dump(field)) # making a deep copy
          
          if col = columns[field[:name]] # <-- column on this model                
            rs << self.extjs_field(field, col)      
          elsif assn = associations[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? assn[:class]
            
            assn_fields = field[:fields]
            if assn[:class].respond_to?(:extjs_record)  # <-- exec extjs_record on assn Model.
              if assn_fields.nil?
                assn_fields = assn[:class].extjs_get_fields_for_fieldset(field.fetch(:fieldset, fieldset))
              end
              
              record = assn[:class].extjs_record(field.fetch(:fieldset, fieldset), { :visited_classes => options[:visited_classes] + [self], :fields => assn_fields})
              rs.concat(record[:fields].collect { |assn_field| 
                self.extjs_field(assn_field, :parent_trail => field[:name], :mapping => field[:name], :allowBlank => true) # <-- allowBlank on associated data?
              })
            elsif assn_fields  # <-- :parent => [:id, :name, :sub => [:id, :name]]
              field_collector = Proc.new do |parent_trail, mapping, assn_field|
                if assn_field.is_a?(Hash) && assn_field.keys.size == 1 && assn_field.keys[0].is_a?(Symbol) && assn_field.values[0].is_a?(Array)
                  field_collector.call(parent_trail.to_s + self.extjs_parent_trail_template.call(assn_field.keys.first), "#{mapping}.#{assn_field.keys.first}", assn_field.values.first) 
                else
                  self.extjs_field(assn_field, :parent_trail => parent_trail, :mapping => mapping, :allowBlank => true)
                end
              end
              rs.concat(assn_fields.collect { |assn_field| field_collector.call(field[:name], field[:name], assn_field) })
            else  
              rs << extjs_field(field)
            end
            
            # attach association's foreign_key if not already included.
            if columns.has_key?(assn[:foreign_key]) && !rs.any? { |r| r[:name] == assn[:foreign_key] }
              rs << extjs_field({:name => assn[:foreign_key]}, columns[assn[:foreign_key]])
            end
            # attach association's type if polymorphic association and not alredy included
            if assn[:is_polymorphic]
              foreign_type = self.extjs_polymorphic_type(assn[:foreign_key])
              if columns.has_key?(foreign_type) && !rs.any? { |r| r[:name] == foreign_type }
                rs << extjs_field({:name => foreign_type}, columns[foreign_type])
              end
            end
          else # property is a method?
            rs << extjs_field(field)
          end
        end
        
        return {
          :fields => rs,
          :idProperty => pk
        }
      end