Ticket #25: patch-25-r252-A1.diff

File patch-25-r252-A1.diff, 15.9 kB (added by elemoine, 1 year ago)

  • tests/data/LayerReader.html

    old new  
     1<!DOCTYPE html> 
     2<html debug="true"> 
     3  <head> 
     4    <script type="text/javascript" src="../../../../openlayers/lib/OpenLayers.js"></script> 
     5    <script type="text/javascript" src="../../../../ext/2.2.1/adapter/ext/ext-base.js"></script> 
     6    <script type="text/javascript" src="../../../../ext/2.2.1/ext-all-debug.js"></script> 
     7    <script type="text/javascript" src="../../lib/GeoExt.js"></script> 
     8 
     9    <script type="text/javascript"> 
     10    function test_constructor(t) { 
     11        t.plan(4); 
     12 
     13        var reader, recordType; 
     14 
     15        reader = new GeoExt.data.LayerReader(); 
     16        var record = new reader.recordType(); 
     17        t.ok(record instanceof GeoExt.data.LayerRecord, 
     18             "ctor creates a LayerRecord type if none is provided"); 
     19 
     20        recordType = [{name: "extra"}]; 
     21        reader = new GeoExt.data.LayerReader(null, recordType); 
     22        t.eq(reader.recordType.prototype.fields.items[2].name, "extra", 
     23             "ctor creates a LayerRecord type with the correct field"); 
     24 
     25        recordType = GeoExt.data.LayerRecord.create([{name: "extra"}]); 
     26        reader = new GeoExt.data.LayerReader(null, recordType); 
     27        t.ok(reader.recordType == recordType, 
     28             "ctor configures reader with passed LayerRecord type"); 
     29 
     30        reader = new GeoExt.data.LayerReader({fields: [{name: "extra"}]}); 
     31        t.eq(reader.recordType.prototype.fields.items[2].name, "extra", 
     32             "ctor creates a LayerRecord type with the correct field"); 
     33    } 
     34 
     35    function test_readRecords(t) { 
     36        t.plan(5); 
     37 
     38        var reader, layers, data; 
     39 
     40        reader = new GeoExt.data.LayerReader(null, [{name: "extra"}]); 
     41        layers = [ 
     42            new OpenLayers.Layer("layer1"), 
     43            new OpenLayers.Layer("layer2") 
     44        ]; 
     45        layers[0].extra = "layer1extra"; 
     46        layers[1].extra = "layer2extra"; 
     47 
     48        data = reader.readRecords(layers); 
     49        t.eq(data.totalRecords, 2, 
     50             "readRecords returns expected number of records"); 
     51        t.ok(data.records[0] instanceof GeoExt.data.LayerRecord, 
     52             "readRecords returns records of expected type"); 
     53        t.ok(data.records[0].get("layer") == layers[0], 
     54             "readRecords returns records with expected \"layer\" field"); 
     55        t.eq(data.records[0].get("title"), layers[0].name, 
     56             "readRecords returns records with expected \"title\" field"); 
     57        t.eq(data.records[0].get("extra"), layers[0].extra, 
     58             "readRecords returns records with expected \"extra\" field"); 
     59    } 
     60    </script> 
     61  <body> 
     62  </body> 
     63</html> 

  • tests/data/LayerStore.html

    old new  
    1616        function loadMapPanel() { 
    1717            var map = createMap(); 
    1818 
    19             mapPanel = new GeoExt.MapPanel({ 
     19            var mapPanel = new GeoExt.MapPanel({ 
    2020                // panel options 
    2121                id: "map-panel", 
    2222                title: "GeoExt MapPanel", 
    …… 
    4141            var layer = new OpenLayers.Layer.Vector("Foo Layer"); 
    4242 
    4343            map.addLayer(layer); 
     44            t.eq(map.layers.length, 1, "Adding layer to map does not create duplicate layers on map"); 
     45            t.eq(mapPanel.layers.getCount(), 1, "Adding layer to map does not create duplicate records in LayerStore"); 
    4446 
    45             t.eq(map.layers.length,1,"Adding layer to map does not create duplicate layers on map"); 
    46             t.eq(mapPanel.layers.getCount(),1,"Adding layer to map does not create duplicate records in LayerStore"); 
    47  
    4847            mapPanel.layers.remove(mapPanel.layers.getById(layer.id)); 
    49  
    5048            t.eq(map.layers.length,0,"removeLayer on MapPanel's LayerStore removes layer from map"); 
    5149            t.eq(mapPanel.layers.getCount(),0,"removeLayer on MapPanel's LayerStore removes layer from map"); 
    5250 
    53             mapPanel.layers.add(new GeoExt.data.LayerRecord(layer)); 
     51            var reader = new GeoExt.data.LayerReader(); 
     52            mapPanel.layers.add((reader.readRecords([layer])).records); 
    5453            t.eq(map.layers.length,1,"Adding layer to MapPanel's LayerStore adds only one layer to map"); 
    5554            t.eq(mapPanel.layers.getCount(),1,"Adding layers to MapPanel's LayerStore does not create duplicate layers");  
    56  
    57  
    5855        } 
    5956    </script> 
    6057  <body> 

  • tests/data/LayerRecord.html

    old new  
    99    <script type="text/javascript"> 
    1010        
    1111        function test_layerrecord(t) { 
    12             t.plan(4); 
     12            t.plan(12); 
     13 
     14            var c, layer, record; 
    1315             
    14             var c = GeoExt.data.LayerRecord.create(); 
    15              
    16             var layer = new OpenLayers.Layer(); 
    17             var record = new c(layer); 
     16            c = GeoExt.data.LayerRecord.create(); 
     17            t.ok(c instanceof Function, "create returns a func"); 
     18            t.eq(c.prototype.fields.items[0].name, "layer", 
     19                 "\"create\" returns a func with a \"layer\" field in its prototype");  
     20            t.eq(c.prototype.fields.items[1].name, "title", 
     21                 "\"create\" returns a func with a \"title\" field in its prototype");  
    1822 
    19             t.ok(record instanceof GeoExt.data.LayerRecord, "create returns a constructor"); 
    20             t.eq(record.get("layer").id, layer.id, "Layer stored correctly"); 
    21             t.eq(record.id, layer.id, "ID set correctly"); 
    22              
    23             var record = new c(layer, {"foo": "bar"}); 
     23            c = GeoExt.data.LayerRecord.create([ 
     24                {name: "extra1"}, {name: "extra2"} 
     25            ]); 
     26            t.eq(c.prototype.fields.items[0].name, "layer", 
     27                 "\"create(o)\" returns a func with a \"layer\" field in its prototype");  
     28            t.eq(c.prototype.fields.items[1].name, "title", 
     29                 "\"create(o)\" returns a func with a \"title\" field in its prototype");  
     30            t.eq(c.prototype.fields.items[2].name, "extra1", 
     31                 "\"create(o)\" returns a func with a \"extra1\" field in its prototype");  
     32            t.eq(c.prototype.fields.items[3].name, "extra2", 
     33                 "\"create(o)\" returns a func with a \"extra2\" field in its prototype");  
     34 
     35            layer = new OpenLayers.Layer(); 
     36            record = new c({layer: layer, title: layer.name}, layer.id); 
     37            t.ok(record instanceof GeoExt.data.LayerRecord, "create returns a constructor (LayerRecord)"); 
     38            t.ok(record instanceof c, "create returns a constructor (c)"); 
     39            t.eq(record.get("layer").id, layer.id, "layer stored correctly"); 
     40            t.eq(record.id, layer.id, "id set correctly"); 
     41            record = new c({layer: layer, title: layer.name, foo: "bar"}, layer.id); 
    2442            t.eq(record.get("foo"), "bar", "foo data row set correctly"); 
    2543        } 
    2644    </script> 

  • tests/list-tests.html

    old new  
    33  <li>data/FeatureStore.html</li> 
    44  <li>data/FeatureStoreMediator.html</li> 
    55  <li>data/LayerRecord.html</li> 
     6  <li>data/LayerReader.html</li> 
    67  <li>data/LayerStore.html</li> 
    78  <li>data/LayerStoreMediator.html</li> 
    89  <li>data/ProtocolProxy.html</li> 

  • lib/GeoExt.js

    old new  
    6060        var jsfiles = new Array( 
    6161            "GeoExt/data/FeatureReader.js", 
    6262            "GeoExt/data/FeatureStore.js", 
     63            "GeoExt/data/LayerRecord.js", 
     64            "GeoExt/data/LayerReader.js", 
    6365            "GeoExt/data/LayerStore.js", 
    64             "GeoExt/data/LayerRecord.js", 
    6566            "GeoExt/data/FeatureStoreMediator.js", 
    6667            "GeoExt/data/RecordLayerMediator.js", 
    6768            "GeoExt/data/LayerStoreMediator.js", 

  • lib/GeoExt/data/LayerStore.js

    old new  
    3737     * {OpenLayers.Map} Map that this store will be in sync with. 
    3838     */ 
    3939    map: null, 
    40      
     40 
    4141    /** 
    42      * APIProperty: recordType 
    43      * {<GeoExt.data.LayerRecord>} type of the layer records used by this 
    44      *     store. 
     42     * Property: reader 
     43     * {<GeoExt.data.LayerReader>} The reader used to get 
     44     *     <GeoExt.data.LayerRecord> objects from {OpenLayers.Layer} 
     45     *     objects. 
    4546     */ 
    46     recordType: null, 
     47    reader: null, 
    4748 
    4849    /** 
    4950     * Constructor: GeoExt.LayerStore 
    …… 
    6364    constructor: function(config) { 
    6465        arguments.callee.superclass.constructor.apply(this, arguments); 
    6566        config = config || {}; 
    66         this.recordType = config.recordType || GeoExt.data.LayerRecord.create(); 
     67        this.reader = new GeoExt.data.LayerReader({}, config.recordType); 
    6768        var map = config.map instanceof GeoExt.MapPanel ? 
    6869            config.map.map : config.map; 
    6970        if(map) { 
    …… 
    7374            // walk through the layers snapshot and add layers to the store 
    7475            for(var i=0; i<layers.length; ++i) { 
    7576                layer = layers[i]; 
    76                 this.add(new this.recordType(layer)); 
     77                this.add((this.reader.readRecords([layer])).records); 
    7778            } 
    7879 
    7980            this.setMap(map); 
    …… 
    111112    onAddLayer: function(evt) { 
    112113        var layer = evt.layer; 
    113114        this._adding = true; 
    114         this.add(new this.recordType(layer)); 
     115        this.add((this.reader.readRecords([layer])).records); 
    115116        delete this._adding; 
    116117    }, 
    117118     

  • lib/GeoExt/data/LayerRecord.js

    old new  
    1 /* Copyright (C) 2008-2009 The Open Source Geospatial Foundation ¹ 
     1/* Copyright (C) 2008-2009 The Open Source Geospatial Foundation 
    22 * Published under the BSD license. 
    33 * See http://geoext.org/svn/geoext/core/trunk/license.txt for the full text 
    44 * of the license. 
    55 *  
    6  * ¹ pending approval */ 
     6 * pending approval */ 
    77 
    88Ext.namespace("GeoExt.data"); 
    99 
    …… 
    1717 * Inherits from 
    1818 * - {Ext.data.Record} 
    1919 */ 
    20 GeoExt.data.LayerRecord = Ext.extend(Ext.data.Record, { 
    21      
    22     /** 
    23      * Constructor: GeoExt.data.LayerRecord 
    24      * This constructor should not be used directly. Instead, the create method of 
    25      * this class should be used to create a constructor. The parameters are the 
    26      * same. 
    27      *  
    28      * Parameters: 
    29      * layer - {OpenLayers.Layer} 
    30      * data - {Object} additional values, keyed by field name 
    31      */ 
    32     constructor: function(layer, data) { 
    33         this.data = Ext.applyIf({ 
    34             title: layer.name, 
    35             layer: layer 
    36         }, data); 
    37         this.id = layer.id; 
    38     } 
    39 }); 
     20GeoExt.data.LayerRecord = Ext.data.Record.create([ 
     21    {name: "layer"}, 
     22    {name: "title", type: "string", mapping: "name"} 
     23]); 
    4024 
    4125/** 
    4226 * APIFunction: GeoExt.data.LayerRecord.create 
    …… 
    4428 * fields. 
    4529 *  
    4630 * Parameters: 
    47  * fieldDefinition - {Array} Field definition as in {Ext.data.Record.create}. 
    48  *     Can be omitted if no additional fields are required (records will 
    49  *     always have a {OpenLayers.Layer} layer and a {String} title field). 
     31 * o - {Array} Field definition as in {Ext.data.Record.create}. Can be omitted 
     32 *     if no additional fields are required (records will always have a 
     33 *     {OpenLayers.Layer} layer and a {String} title field). 
     34 * 
     35 * Returns: 
     36 * {Function} A specialized {<GeoExt.data.LayerRecord>} constructor. 
    5037 */ 
    51 GeoExt.data.LayerRecord.create = function(fieldDefinition) { 
    52     var o = [ 
    53         {name: "layer"}, 
    54         {name: "title"} 
    55     ].concat(fieldDefinition); 
    56  
     38GeoExt.data.LayerRecord.create = function(o) { 
    5739    var f = Ext.extend(GeoExt.data.LayerRecord, {}); 
    5840    var p = f.prototype; 
    59     p.fields = new Ext.util.MixedCollection(false, function(field){ 
    60         return field.name; 
    61     }); 
    62     for(var i = 0, len = o.length; i < len; i++){ 
    63         p.fields.add(new Ext.data.Field(o[i])); 
     41    if(o) { 
     42        for(var i = 0, len = o.length; i < len; i++){ 
     43            p.fields.add(new Ext.data.Field(o[i])); 
     44        } 
    6445    } 
    65     f.getField = function(name){ 
    66         return p.fields.get(name); 
    67     }; 
    6846    return f; 
    6947} 

  • lib/GeoExt/data/LayerReader.js

    old new  
     1/* Copyright (C) 2008-2009 The Open Source Geospatial Foundation 
     2 * Published under the BSD license. 
     3 * See http://geoext.org/svn/geoext/core/trunk/license.txt for the full text 
     4 * of the license. 
     5 *  
     6 * ¹ pending approval */ 
     7 
     8Ext.namespace("GeoExt", "GeoExt.data"); 
     9 
     10/** 
     11 * Class: GeoExt.data.LayerReader 
     12 *      LayerReader is a specific Ext.data.DataReader for converting 
     13 *      layers into layer records, i.e. {OpenLayers.Layer} objects 
     14 *      into {GeoExt.data.LayerRecor} objects. 
     15 * 
     16 * Usage example: 
     17 * (start code) 
     18 *         var reader = new GeoExt.data.LayerReader(); 
     19 *         var layerData = reader.readRecords(map.layers); 
     20 *         var numRecords = layerData.totalRecords; 
     21 *         var layerRecords = layerData.records; 
     22 * (end) 
     23 * 
     24 * Inherits from: 
     25 *  - {Ext.data.DataReader} 
     26 */ 
     27 
     28/** 
     29 * Constructor: GeoExt.data.LayerReader 
     30 *      Create a layer reader. The arguments passed are similar to those 
     31 *      passed to {Ext.data.DataReader} constructor. 
     32 */ 
     33GeoExt.data.LayerReader = function(meta, recordType) { 
     34    meta = meta || {}; 
     35    if(!(recordType instanceof Function)) { 
     36        recordType = GeoExt.data.LayerRecord.create( 
     37            recordType || meta.fields || {}); 
     38    } 
     39    GeoExt.data.LayerReader.superclass.constructor.call( 
     40        this, meta, recordType); 
     41}; 
     42 
     43Ext.extend(GeoExt.data.LayerReader, Ext.data.DataReader, { 
     44 
     45    /** 
     46     * APIProperty: totalRecords 
     47     * {Integer} 
     48     */ 
     49    totalRecords: null, 
     50 
     51    /** 
     52     * APIMethod: readRecords 
     53     *      From an array of {OpenLayers.Layer} objects create a data block 
     54     *      containing {<GeoExt.data.LayerRecord>} objects. 
     55     * 
     56     * Parameters: 
     57     * layers - {Array({OpenLayers.Layer})} Array of layers. 
     58     * 
     59     * Returns: 
     60     * {Object} An object with two properties. The value of the property "records" 
     61     *      is the array of layer records. The value of the property "totalRecords" 
     62     *      is the number of records in the array. 
     63     */ 
     64    readRecords : function(layers) { 
     65        var records = []; 
     66        if(layers) { 
     67            var recordType = this.recordType, fields = recordType.prototype.fields; 
     68            var i, lenI, j, lenJ, layer, values, field, v; 
     69            for(i = 0, lenI = layers.length; i < lenI; i++) { 
     70                layer = layers[i]; 
     71                values = {}; 
     72                for(j = 0, lenJ = fields.length; j < lenJ; j++){ 
     73                    field = fields.items[j]; 
     74                    v = layer[field.mapping || field.name] || 
     75                        field.defaultValue; 
     76                    v = field.convert(v); 
     77                    values[field.name] = v; 
     78                } 
     79                values.layer = layer; 
     80                records[records.length] = new recordType(values, layer.id); 
     81            } 
     82        } 
     83        return { 
     84            records: records, 
     85            totalRecords: this.totalRecords != null ? this.totalRecords : records.length 
     86        }; 
     87    } 
     88});