rgeoserver 0.5.9 → 0.7

data/lib/rgeoserver/featuretype.rb

@@ -1,21 +1,41 @@
 
 module RGeoServer
-  # A feature type is a vector based spatial resource or data set that originates from a data store. In some cases, like Shapefile, a feature type has a one-to-one relationship with its data store. In other cases, like PostGIS, the relationship of feature type to data store is many-to-one, with each feature type corresponding to a table in the database.
-  class FeatureType < ResourceInfo
-    OBJ_ATTRIBUTES = {:catalog => "catalog", :name => "name", :workspace => "workspace", :data_store => "data_store", :enabled => "enabled", :metadata_links => "metadataLinks", :title => "title", :abstract => "abstract", :native_bounds => 'native_bounds', :latlon_bounds => "latlon_bounds", :projection_policy => 'projection_policy'}
-    OBJ_DEFAULT_ATTRIBUTES =
-      {
+  # A feature type is a vector based spatial resource or data set that originates from a data store.
+  # In some cases, like Shapefile, a feature type has a one-to-one relationship with its data store.
+  # In other cases, like PostGIS, the relationship of feature type to data store is many-to-one, with
+  # each feature type corresponding to a table in the database.
+  class FeatureType < ResourceInfo    
+    OBJ_ATTRIBUTES = {
+      :catalog => "catalog", 
+      :name => "name", 
+      :native_name => "nativeName", 
+      :workspace => "workspace", 
+      :data_store => "data_store", 
+      :enabled => "enabled", 
+      :metadata => "metadata", 
+      :metadata_links => "metadataLinks", 
+      :title => "title", 
+      :abstract => "abstract",
+      :keywords => 'keywords',
+      :native_bounds => 'native_bounds', 
+      :latlon_bounds => "latlon_bounds", 
+      :projection_policy => 'projection_policy'
+    }
+    OBJ_DEFAULT_ATTRIBUTES = {
       :catalog => nil,
       :workspace => nil,
       :data_store => nil,
       :name => nil,
+      :native_name => nil,
       :enabled => "false",
-      :metadata_links => [],
+      :metadata => {},
+      :metadata_links => {},
       :title => nil,
       :abstract => nil,
+      :keywords => [],
       :native_bounds => {'minx'=>nil, 'miny' =>nil, 'maxx'=>nil, 'maxy'=>nil, 'crs' =>nil},
       :latlon_bounds => {'minx'=>nil, 'miny' =>nil, 'maxx'=>nil, 'maxy'=>nil, 'crs' =>nil},
-      :projection_policy => :force
+      :projection_policy => :keep
     }
 
     define_attribute_methods OBJ_ATTRIBUTES.keys
@@ -25,6 +45,19 @@ module RGeoServer
     @@root = "featureTypes"
     @@resource_name = "featureType"
 
+    # see http://inspire.ec.europa.eu/schemas/common/1.0/common.xsd
+    METADATA_TYPES = {
+      'ISO19139' => 'text/xml',
+      'TC211' => 'text/xml'
+    }
+    
+    # see https://github.com/geoserver/geoserver/blob/master/src/main/src/main/java/org/geoserver/catalog/ProjectionPolicy.java
+    PROJECTION_POLICIES = {
+      :force => 'FORCE_DECLARED',
+      :reproject => 'REPROJECT_TO_DECLARED',
+      :keep => 'NONE'
+    }
+
     def self.root
       @@root
     end
@@ -42,20 +75,45 @@ module RGeoServer
     end
 
     def route
+      raise GeoServerArgumentError, "workspace not defined" unless @workspace
+      raise GeoServerArgumentError, "data_store not defined" unless @data_store
       @@route % [@workspace.name , @data_store.name]
     end
+    
+    def to_mimetype(type, default = 'text/xml')
+      k = type.to_s.strip.upcase
+      return METADATA_TYPES[k] if METADATA_TYPES.include? k
+      default
+    end
 
     def message
       builder = Nokogiri::XML::Builder.new do |xml|
         xml.featureType {
-          xml.name @name if new?
-          xml.enabled @enabled if (enabled_changed? || new?)
-          xml.title title
-          xml.abstract abstract
+          xml.nativeName @native_name.nil?? @name : @native_name if new? # on new only
+          xml.name @name
+          xml.enabled @enabled
+          xml.title @title
+          xml.abstract @abstract
+          xml.keywords {
+            @keywords.compact.uniq.each do |k|
+              xml.string RGeoServer::Metadata::to_keyword(k)
+            end
+          } unless @keywords.empty?
 
+          xml.metadataLinks {
+            @metadata_links.each do |m|
+              raise ArgumentError, "Malformed metadata_links" unless m.is_a? Hash
+              xml.metadataLink {
+                xml.type_ to_mimetype(m['metadataType'])
+                xml.metadataType m['metadataType']
+                xml.content m['content']
+              }
+            end
+          } unless @metadata_links.empty?
+          
           xml.store(:class => 'dataStore') {
             xml.name @data_store.name
-          } if new? || data_store_changed?
+          } if new? or data_store_changed?
 
           xml.nativeBoundingBox {
             xml.minx native_bounds['minx'] if native_bounds['minx']
@@ -63,7 +121,7 @@ module RGeoServer
             xml.maxx native_bounds['maxx'] if native_bounds['maxx']
             xml.maxy native_bounds['maxy'] if native_bounds['maxy']
             xml.crs native_bounds['crs'] if native_bounds['crs']
-          } if valid_native_bounds?
+          } if valid_native_bounds? and (new? or native_bounds_changed?)
 
           xml.latLonBoundingBox {
             xml.minx latlon_bounds['minx'] if latlon_bounds['minx']
@@ -71,11 +129,11 @@ module RGeoServer
             xml.maxx latlon_bounds['maxx'] if latlon_bounds['maxx']
             xml.maxy latlon_bounds['maxy'] if latlon_bounds['maxy']
             xml.crs latlon_bounds['crs'] if latlon_bounds['crs']
-          } if valid_latlon_bounds?
+          } if valid_latlon_bounds? and (new? or latlon_bounds_changed?)
 
-          xml.projectionPolicy get_projection_policy_message(projection_policy) if projection_policy
+          xml.projectionPolicy get_projection_policy_message(projection_policy) if projection_policy and new? or projection_policy_changed?
 
-          if new?
+          if new? # XXX: hard coded attributes
             xml.attributes {
               xml.attribute {
                 xml.name 'the_geom'
@@ -85,44 +143,38 @@ module RGeoServer
                 xml.binding 'com.vividsolutions.jts.geom.Point'
               }
             }
-          else
-            xml.metadataLinks {
-              @metadata_links.each{ |m|
-                xml.metadataLink {
-                  xml.type_ m['type']
-                  xml.metadataType m['metadataType']
-                  xml.content m['content']
-                }
-              }
-            } if metadata_links_changed?
           end
         }
       end
       @message = builder.doc.to_xml
+      ap({:message => @message}) if $DEBUG
+      @message
     end
 
 
     # @param [RGeoServer::Catalog] catalog
     # @param [Hash] options
     def initialize catalog, options
-      super({})
+      raise GeoServerArgumentError, "FeatureType.new requires :data_store option" unless options.include?(:data_store)
+      raise GeoServerArgumentError, "FeatureType.new requires :name option" unless options.include?(:name)
+      super(catalog)
       _run_initialize_callbacks do
-        @catalog = catalog
         workspace = options[:workspace] || 'default'
         if workspace.instance_of? String
           @workspace = @catalog.get_workspace(workspace)
         elsif workspace.instance_of? Workspace
           @workspace = workspace
         else
-          raise "Not a valid workspace"
+          raise GeoServerArgumentError, "Not a valid workspace: #{workspace}"
         end
+        
         data_store = options[:data_store]
         if data_store.instance_of? String
-          @data_store = DataStore.new @catalog, :workspace => @workspace, :name => data_store
+          @data_store = @catalog.get_data_store(@workspace.name, data_store)
         elsif data_store.instance_of? DataStore
           @data_store = data_store
         else
-          raise "Not a valid data store"
+          raise GeoServerArgumentError, "Not a valid datastore: #{data_store}"
         end
 
         @name = options[:name].strip
@@ -132,77 +184,88 @@ module RGeoServer
 
     def profile_xml_to_hash profile_xml
       doc = profile_xml_to_ng profile_xml
+      ft = doc.at_xpath('//' + FeatureType::resource_name)
+      ap({:doc => doc, :ft => ft}) if $DEBUG
       h = {
-        "name" => doc.at_xpath('//name').text.strip,
-        "title" => doc.at_xpath('//title/text()').to_s,
-        "abstract" => doc.at_xpath('//abstract/text()').to_s,
+        "name" => ft.at_xpath('name').text,
+        "native_name" => ft.at_xpath('nativeName').text,
+        "title" => ft.at_xpath('title').text,
+        "abstract" => ft.at_xpath('abstract/text()'), # optional
+        "keywords" => ft.xpath('keywords/string').collect { |k| k.at_xpath('.').text},
         "workspace" => @workspace.name,
         "data_store" => @data_store.name,
-        "nativeName" => doc.at_xpath('//nativeName/text()').to_s,
-        "srs" => doc.at_xpath('//srs/text()').to_s,
+        "srs" => ft.at_xpath('srs').text,
         "native_bounds" => {
-          'minx' => doc.at_xpath('//nativeBoundingBox/minx/text()').to_s.to_f,
-          'miny' => doc.at_xpath('//nativeBoundingBox/miny/text()').to_s.to_f,
-          'maxx' => doc.at_xpath('//nativeBoundingBox/maxx/text()').to_s.to_f,
-          'maxy' => doc.at_xpath('//nativeBoundingBox/maxy/text()').to_s.to_f,
-          'crs' => doc.at_xpath('//nativeBoundingBox/crs/text()').to_s
+          'minx' => ft.at_xpath('nativeBoundingBox/minx').text.to_f,
+          'miny' => ft.at_xpath('nativeBoundingBox/miny').text.to_f,
+          'maxx' => ft.at_xpath('nativeBoundingBox/maxx').text.to_f,
+          'maxy' => ft.at_xpath('nativeBoundingBox/maxy').text.to_f,
+          'crs' => ft.at_xpath('srs').text
         },
         "latlon_bounds" => {
-          'minx' => doc.at_xpath('//latLonBoundingBox/minx/text()').to_s.to_f,
-          'miny' => doc.at_xpath('//latLonBoundingBox/miny/text()').to_s.to_f,
-          'maxx' => doc.at_xpath('//latLonBoundingBox/maxx/text()').to_s.to_f,
-          'maxy' => doc.at_xpath('//latLonBoundingBox/maxy/text()').to_s.to_f,
-          'crs' => doc.at_xpath('//latLonBoundingBox/crs/text()').to_s
+          'minx' => ft.at_xpath('latLonBoundingBox/minx').text.to_f,
+          'miny' => ft.at_xpath('latLonBoundingBox/miny').text.to_f,
+          'maxx' => ft.at_xpath('latLonBoundingBox/maxx').text.to_f,
+          'maxy' => ft.at_xpath('latLonBoundingBox/maxy').text.to_f,
+          'crs' => ft.at_xpath('latLonBoundingBox/crs').text
         },
-        "projection_policy" => get_projection_policy_sym(doc.at_xpath('//projectionPolicy').text.strip),
-        "metadataLinks" => doc.xpath('//metadataLinks/metadataLink').collect{ |m|
+        "projection_policy" => get_projection_policy_sym(ft.at_xpath('projectionPolicy').text),
+        "metadata_links" => ft.xpath('metadataLinks/metadataLink').collect{ |m|
           {
-            'type' => m.at_xpath('//type/text()').to_s,
-            'metadataType' => m.at_xpath('//metadataType/text()').to_s,
-            'content' => m.at_xpath('//content/text()').to_s
+            'type' => m.at_xpath('type').text,
+            'metadataType' => m.at_xpath('metadataType').text,
+            'content' => m.at_xpath('content').text
           }
         },
-        "attributes" => doc.xpath('//attributes/attribute').collect{ |a|
+        "attributes" => ft.xpath('attributes/attribute').collect{ |a|
           {
-            'name' => a.at_xpath('//name/text()').to_s,
-            'minOccurs' => a.at_xpath('//minOccurs/text()').to_s,
-            'maxOccurs' => a.at_xpath('//maxOccurs/text()').to_s,
-            'nillable' => a.at_xpath('//nillable/text()').to_s,
-            'binding' => a.at_xpath('//binding/text()').to_s
+            'name' => a.at_xpath('name').text,
+            'minOccurs' => a.at_xpath('minOccurs').text,
+            'maxOccurs' => a.at_xpath('maxOccurs').text,
+            'nillable' => a.at_xpath('nillable').text,
+            'binding' => a.at_xpath('binding').text
           }
         }
       }.freeze
+      ap({:h => h}) if $DEBUG
       h
     end
 
     def valid_native_bounds?
-      native_bounds &&
-        ![native_bounds['minx'], native_bounds['miny'], native_bounds['maxx'], native_bounds['maxy'], native_bounds['crs']].compact.empty?
+      bbox = RGeoServer::BoundingBox.new(native_bounds)
+      ap bbox if $DEBUG
+      not bbox.nil? and bbox.valid? and not native_bounds['crs'].empty?
     end
 
     def valid_latlon_bounds?
-      latlon_bounds &&
-        ![latlon_bounds['minx'], latlon_bounds['miny'], latlon_bounds['maxx'], latlon_bounds['maxy'], latlon_bounds['crs']].compact.empty?
+      bbox = RGeoServer::BoundingBox.new(latlon_bounds)
+      ap bbox if $DEBUG
+      not bbox.nil? and bbox.valid? and not latlon_bounds['crs'].empty?
+    end
+    
+    def update_params name_route = name
+      super(name_route)
+      # recalculate='nativebbox,latlonbbox'
     end
 
     private
+    
     def get_projection_policy_sym value
-      case value.upcase
-      when 'FORCE_DECLARED' then :force
-      when 'REPROJECT_TO_DECLARED' then :reproject
-      when 'NONE' then :keep
+      v = value.strip.upcase
+      if PROJECTION_POLICIES.has_value? v
+        PROJECTION_POLICIES.invert[v]
       else
-        raise ArgumentError, "There is not correspondent to '%s'" % value
+        raise GeoServerArgumentError, "Invalid PROJECTION_POLICY: #{v}"
       end
     end
 
     def get_projection_policy_message value
-      case value
-      when :force then 'FORCE_DECLARED'
-      when :reproject then 'REPROJECT_TO_DECLARED'
-      when :keep then 'NONE'
+      k = value
+      k = value.strip.to_sym if not value.is_a? Symbol
+      if PROJECTION_POLICIES.has_key? k
+        PROJECTION_POLICIES[k]
       else
-        raise ArgumentError, "There is not correspondent to '%s'" % value
+        raise GeoServerArgumentError, "Invalid PROJECTION_POLICY: #{k}"
       end
     end
   end

data/lib/rgeoserver/geoserver_url_helpers.rb

@@ -1,17 +1,147 @@
 
 module RGeoServer
   module GeoServerUrlHelpers
-    API_DOCUMENTATION = "http://docs.geoserver.org/latest/en/user/restconfig/rest-config-api.html"
-  
-    def url_for base, options = nil
-      base = { base => nil } unless base.is_a? Hash
-      format = options.delete(:format) || 'xml'
-      new_base = base.map{ |key,value|  value.nil?? key.to_s : [key.to_s, CGI::escape(value.to_s)].join("/")  }.join("/") 
-      new_base = new_base.gsub(/\/$/,'')
-      new_base += ".#{format}"
-      "#{new_base}" + (("?#{options.map { |key, value|  "#{CGI::escape(key.to_s)}=#{CGI::escape(value.to_s)}"}.join("&")  }" if options and not options.empty?) || '')
-
+        
+    # Valid URI sequences for REST API
+    # See http://docs.geoserver.org/stable/en/user/rest/index.html
+    URI_SEQUENCES = [
+      %w{settings},
+      %w{settings contact},
+      %w{workspaces},
+      %w{workspaces settings},
+      %w{namespaces},
+      %w{workspaces datastores},
+      %w{workspaces datastores file},
+      %w{workspaces datastores external},
+      %w{workspaces datastores url},
+      %w{workspaces datastores featuretypes},
+      %w{workspaces coveragestores},
+      %w{workspaces coveragestores file},
+      %w{workspaces coveragestores coverages},
+      %w{styles},
+      %w{workspaces styles},
+      %w{layers},
+      %w{layers styles},
+      %w{layergroups},
+      %w{workspaces layergroups},
+      %w{fonts},
+      %w{templates},
+      %w{services wcs settings},
+      %w{services wfs settings},
+      %w{services wms settings},
+      %w{reload},
+      %w{reset},
+      %w{about}
+    ].map {|x| x.map(&:to_sym)}
+    
+    # Regexp processing for #URI_SEQUENCES
+    URI_REGEX = URI_SEQUENCES.map do |a|
+      Regexp.new('^' + a.map {|x| x.to_s}.join('/\w+/') + '[/\w]*$')
     end
+        
+    # Valid formats for REST API
+    # See http://docs.geoserver.org/stable/en/user/rest/api/details.html
+    URI_FORMATS = %w{xml json html sld zip}.map(&:to_sym)
+    
+    # See http://docs.geoserver.org/latest/en/user/rest/api/
+    # @param [Hash] base, examples:
+    # - { :workspaces => nil }
+    #
+    # @param [Hash] options
+    # @return [String] baseURL for REST API, e.g.,:
+    # - settings.xml
+    # - layers/_name_.xml
+    # - styles/_name_.xml
+    # - workspaces/_name_.xml
+    # - workspaces/_name_/settings.xml
+    # - namespaces/_name_.xml
+    # - workspaces/_name_/datastores/_name_.xml
+    # - workspaces/_name_/datastores/_name_/featuretype/_name_.xml
+    def url_for base, options = {}
+      raise GeoServerArgumentError, "options must be Hash" unless options.is_a? Hash
+      if base.is_a? String
+        $stderr.puts "WARNING: deprecated usage -- base should be Hash"
+        base = { base.to_sym => nil } if base.is_a? String
+      end
 
+      base = Hash[base.map {|k,v| [k.to_sym, v]}] unless base.keys.select {|k| not k.is_a? Symbol}.size == 0
+      
+      format = (options.delete(:format) if options.include?(:format)) || :xml
+      raise GeoServerArgumentError, "Unknown REST API format: '#{format}'" unless URI_FORMATS.include?(format)
+      
+      new_base = base.collect {|k,v| v.nil?? "#{k}" : "#{k}/#{v}"}.join('/').to_s
+      new_base = new_base.gsub(%r{/$}, '')
+      
+      raise GeoServerArgumentError, "Invalid REST URI syntax: #{new_base} from #{base}" unless URI_REGEX.each.select {|r| r.match(new_base)}.size > 0
+      
+      new_base += ".#{format}"
+      if not options.empty?
+        new_base += "?" + options.collect {|k,v| [CGI::escape(k.to_s), CGI::escape(v.to_s)].join('=')}.join('&')
+      end
+      ap "url_for: #{base} #{options} => #{new_base}" if $DEBUG
+      new_base
+    end
+    
+    # See http://docs.geoserver.org/latest/en/user/rest/api/
+    # @param [Hash] sequence with values. Note that the sequence can end in a nil, but none of the preceding elements may be nil
+    # - 'workspaces'
+    # - { :workspaces => nil }
+    # - { :workspaces => 'default', :datastores => nil }
+    # - { :about => 'version' }
+    #
+    # @param [Hash] options :format. See `URI_FORMATS`
+    #
+    # @return [String] baseURL for REST API, e.g.,:
+    # - workspaces.xml
+    # - workspaces/_name_.json
+    # - workspaces/_name_/datastores.xml
+    # - workspaces/_name_/datastores/_name_/featuretype/_name_.xml
+    #
+    # @raise [GeoServerArgumentError] if sequence is invalid
+    # def url_for_NOT_READY sequence, options = { }
+    #   if sequence.is_a? Hash
+    #     # ap "url_for(String): #{sequence}"
+    #     new_base = sequence
+    #   else
+    #     # ap "url_for(Hash): #{sequence}"
+    #     raise GeoServerArgumentError, "sequence must be Hash" unless sequence.is_a? Hash
+    #     if sequence.keys.select {|k| k.is_a? Symbol}.empty?
+    #       raise GeoServerArgumentError, "Sequence must use symbol keys: #{sequence}"
+    #     end
+    # 
+    #     raise GeoServerArgumentError, "Invalid sequence: #{sequence}" unless URI_SEQUENCES.include?(sequence.keys.to_a)
+    # 
+    #     # sequence can end in a nil, but none of the preceding elements may
+    #     if sequence.size > 1
+    #       sequence.keys.slice(0..-2).reverse_each do |k|
+    #         raise GeoServerArgumentError, "Missing required sequence value for #{k}: #{sequence}" if sequence[k] == nil
+    #       end
+    #     end
+    # 
+    #     # `about` sequence can only be :version or :manifest
+    #     if sequence.include?(:about) and not [:manifest, :version].include?(sequence[:about])
+    #       raise GeoServerArgumentError, "Missing required sequence symbol for about [:manifest, :version]: #{sequence}"
+    #     end
+    # 
+    #     if sequence.keys == [:layers, :styles]
+    #       raise GeoServerArgumentError, "Cannot retrieve specific layer style: #{sequence}" if sequence[:styles] != nil
+    #     end
+    # 
+    #     raise GeoServerArgumentError, "options must be Hash: #{options}" unless options.is_a? Hash      
+    #     format = options.delete(:format) || :xml
+    #     raise GeoServerArgumentError, "Unknown REST API format: '#{format}'" unless URI_FORMATS.include?(format)
+    # 
+    #     new_base = sequence.collect {|k,v| v.nil?? "#{k}" : "#{k}/#{v}"}.join('/')
+    #   end
+    #   
+    #   raise TypeError if new_base.is_a? String if $DEBUG
+    #   
+    #   new_base = new_base.gsub(/\/$/,'')
+    #   new_base += ".#{format}"
+    #   if not options.empty?
+    #     new_base += "?" + CGI::escape(options.collect {|k,v| "#{k}=#{v}"}.join('&'))
+    #   end
+    #   new_base
+    # end
   end
 end

data/lib/rgeoserver/layer.rb

@@ -98,14 +98,22 @@ module RGeoServer
 
     # @param [RGeoServer::Catalog] catalog
     # @param [Hash] options
-    # @option options [String] :name
+    # @option options [String] :name required
     # @option options [String] :default_style
     # @option options [Array<String>] :alternate_styles
     def initialize catalog, options
-      super({})
+      super(catalog)
       _run_initialize_callbacks do
-        @catalog = catalog
-        @name = options[:name].strip
+        if options[:name].instance_of? Layer
+          options[:name] = options[:name].name.to_s
+        end
+        
+        raise GeoServerArgumentError, "Layer requires :name option" unless options.include? :name and options[:name].is_a? String
+        @name = options[:name].to_s.strip
+        ap({:init_name => @name}) if $DEBUG
+        
+        raise NotImplementedError, ":default_style" if options.include? :default_style
+        raise NotImplementedError, ":alternate_styles" if options.include? :alternate_styles
         #@default_style = options[:default_style] || ''
         #@alternate_styles = options[:alternate_styles] || []
       end
@@ -116,7 +124,7 @@ module RGeoServer
       if r.is_a?(RGeoServer::Coverage) || r.is_a?(RGeoServer::FeatureType)
         @resource = r
       else
-        raise 'Unknown resource type'
+        raise GeoServerArgumentError, 'Unknown resource type: #{r.class}'
       end
     end
 
@@ -132,9 +140,17 @@ module RGeoServer
           when 'coverage'
             return RGeoServer::Coverage.new @catalog, :workspace => workspace, :coverage_store => store, :name => name
           when 'featureType'
-            return RGeoServer::FeatureType.new @catalog, :workspace => workspace, :data_store => store, :name => name
+            ap({:catalog => @catalog, :workspace => workspace, :data_store => store, :name => name}) if $DEBUG
+            begin
+              ft = RGeoServer::FeatureType.new @catalog, :workspace => workspace, :data_store => store, :name => name
+              ap({:featureType => ft, :route => ft.route}) if $DEBUG
+            rescue Exception => e
+              ap({:errormsg => "#{e}", :error => e, :trace => e.backtrace}) if $DEBUG
+            end
+            
+            return ft
           else
-            raise 'Unknown resource type'
+            raise GeoServerArgumentError, 'Unknown resource type: #{data_type}'
           end
         else
           nil
@@ -146,11 +162,11 @@ module RGeoServer
 
     # TODO: Simplify if necessary with "/layers/<l>/styles[.<format>]", as specified in the API
     def get_default_style &block
-      self.class.list Style, @catalog, @default_style, {:layer => self}, check_remote = false, &block
+      self.class.list Style, @catalog, @default_style, {:layer => self}, false, &block
     end
 
     def get_alternate_styles &block
-      self.class.list Style, @catalog, @alternate_styles, {:layer => self}, check_remote = false, &block
+      self.class.list Style, @catalog, @alternate_styles, {:layer => self}, false, &block
     end
 
     def profile_xml_to_hash profile_xml
@@ -179,7 +195,7 @@ module RGeoServer
           "store" => store,
           "workspace" => workspace
         },
-        "metadata" => doc.xpath('//metadata/entry').inject({}){ |h, e| h.merge(e['key']=> e.text.to_s) }
+        "metadata" => doc.xpath('//metadata/entry').inject({}){ |h2, e| h2.merge(e['key']=> e.text.to_s) }
       }.freeze
       h
     end
@@ -188,6 +204,12 @@ module RGeoServer
       resource.workspace
     end
 
+    # Return full name of resource with namespace prefix
+    def prefixed_name
+      return "#{workspace.name}:#{name}" if self.respond_to?(:workspace)
+      raise "Workspace is not defined for this resource"
+    end
+
     #= GeoWebCache Operations for this layer
     # See http://geowebcache.org/docs/current/rest/seed.html
     # See RGeoServer::Catalog.seed_terminate for stopping pending and/or running tasks for any layer
@@ -202,6 +224,8 @@ module RGeoServer
     #    :threadCount => 1
     #  }
     #  > lyr.seed :issue, options
+    #
+    # @see http://geowebcache.org/docs/current/rest/
 
     # @param[String] operation
     # @option operation[Symbol] :issue seed
@@ -213,16 +237,25 @@ module RGeoServer
       sub_path = "seed/#{prefixed_name}.xml"
       case op
       when :issue
-        @catalog.do_url sub_path, :post, build_seed_request(:seed, options), {},  @catalog.gwc_client
+        @catalog.do_url sub_path, :post, _build_seed_request(:seed, options), {},  @catalog.gwc_client
       when :truncate
-        @catalog.do_url sub_path, :post, build_seed_request(:truncate, options), {}, @catalog.gwc_client
+        @catalog.do_url sub_path, :post, _build_seed_request(:truncate, options), {}, @catalog.gwc_client
       when :status
-        raise NotImplementedError
+        raise NotImplementedError, "#{op}"
       end
     end
 
-    # @param[Hash] options for seed message
-    def build_seed_request operation, options
+    private
+    # @param[Hash] options for seed message, requiring
+    #  options[:srs][:number]
+    #  options[:bounds][:coords]
+    #  options[:gridSetId]
+    #  options[:zoomStart]
+    #  options[:zoomStop]
+    #  options[:gridSetId]
+    #  options[:gridSetId]
+    #
+    def _build_seed_request operation, options
       builder = Nokogiri::XML::Builder.new do |xml|
         xml.seedRequest {
           xml.name prefixed_name
@@ -241,9 +274,11 @@ module RGeoServer
 
           xml.type_ operation
 
-          [:gridSetId, :zoomStart, :zoomStop, :format, :threadCount].each { |p|
+          [:gridSetId, :zoomStart, :zoomStop, :threadCount].each { |p|
             eval "xml.#{p.to_s} options[p]" unless options[p].nil?
           }
+          
+          xml.format_ options[:tileFormat] unless options[:tileFormat].nil?
 
           xml.parameters {
             options[:parameters].each_pair { |k,v|
@@ -255,6 +290,7 @@ module RGeoServer
           } if options[:parameters].is_a?(Hash)
         }
       end
+      ap({:build_seed_request => builder.doc}) if $DEBUG
       return builder.doc.to_xml
     end
   end

data/lib/rgeoserver/layergroup.rb

@@ -68,9 +68,8 @@ module RGeoServer
     # @param [Hash] options
     # @option options [String] :name
     def initialize catalog, options
-      super({})
+      super(catalog)
       _run_initialize_callbacks do
-        @catalog = catalog
         @name = options[:name].strip
         @workspace = options[:workspace]
       end

data/lib/rgeoserver/namespace.rb

@@ -41,9 +41,8 @@ module RGeoServer
     # @param [RGeoServer::Catalog] catalog
     # @param [Hash] options
     def initialize catalog, options
-      super({})
+      super(catalog)
       _run_initialize_callbacks do
-        @catalog = catalog
         @name = options[:name].strip
         @uri = options[:uri] if options[:uri]
       end