rgeoserver 0.5.8.2 → 0.5.9

data/.rspec

@@ -0,0 +1 @@
+-c

data/Gemfile

@@ -2,6 +2,8 @@ source "http://rubygems.org"
 
 gemspec
 
+# general
 gem 'activemodel'
-
-
+gem 'rubyzip'
+gem 'rgeo'
+gem 'rgeo-shapefile'

data/README.rdoc

@@ -10,7 +10,7 @@ It provides primitive Ruby model abstraction.
 == Documentation
 The GeoServer REST Configuration API Reference can be found here:
 
-http://docs.geoserver.org/stable/en/user/restconfig/rest-config-api.html
+http://docs.geoserver.org/stable/en/user/rest/index.html
 
  
 == Installation 
@@ -162,10 +162,14 @@ result as the ResourceInfo#save method.
 Inspired on the {Rubydora}[https://github.com/cbeer/rubydora] gem. Followed somewhat closely to {gsconfig.py}[https://github.com/dwins/gsconfig.py] 
 
 == Contributors
+This package is supported and maintained by Stanford University Libraries.
 
+Bess Sadler <bess@stanford.edu>
 
 == License 
 
-Copyright (c) 2012 Renzo Sanchez-Silva <renzo@stanford.edu>.
+Copyright (c) 2012 Stanford University
 
-Licensed under the {MIT License}[http://www.opensource.org/licenses/MIT].
+Author: Renzo Sanchez-Silva <renzo.sanchez.silva@gmail.com>.
+
+Licensed under the Apache License, Version 2.0

data/VERSION

@@ -1 +1 @@
-0.5.8.2
+0.5.9

data/lib/rgeoserver.rb

@@ -19,6 +19,9 @@ module RGeoServer
   autoload :Layer, "rgeoserver/layer"
   autoload :LayerGroup, "rgeoserver/layergroup"
 
+  autoload :BoundingBox, "rgeoserver/utils/boundingbox"
+  autoload :ShapefileInfo, "rgeoserver/utils/shapefile_info"
+
   require 'restclient'
   require 'nokogiri'
   require 'time'
@@ -30,7 +33,7 @@ module RGeoServer
 
   def self.catalog
     @catalog ||= self.connect(self.default_config.geoserver)
-  end 
+  end
 
   def self.catalog= catalog
     @catalog = catalog

data/lib/rgeoserver/catalog.rb

@@ -1,12 +1,12 @@
 module RGeoServer
   # This class represents the main class of the data model.
-  # Refer to 
+  # Refer to
   # - http://geoserver.org/display/GEOS/Catalog+Design
   # - http://docs.geoserver.org/stable/en/user/restconfig/rest-config-api.html#workspaces
 
   class Catalog
     include RGeoServer::RestApiClient
-    
+
     attr_reader :config
 
     # @param [OrderedHash] options
@@ -27,14 +27,14 @@ module RGeoServer
     end
 
     #== Resources
-  
+
     # Shortcut to ResourceInfo.list to this catalog. See ResourceInfo#list
     # @param [RGeoServer::ResourceInfo.class] klass
     # @param [RGeoServer::Catalog] catalog
     # @param [Array<String>] names
     # @param [Hash] options
     # @param [bool] check_remote if already exists in catalog and cache it
-    # @yield [RGeoServer::ResourceInfo] 
+    # @yield [RGeoServer::ResourceInfo]
     def list klass, names, options, check_remote = false,  &block
       ResourceInfo.list klass, self, names, options, check_remote, &block
     end
@@ -44,12 +44,12 @@ module RGeoServer
     # List of available workspaces
     # @return [Array<RGeoServer::Workspace>]
     def get_workspaces &block
-      response = self.search :workspaces => nil 
+      response = self.search :workspaces => nil
       doc = Nokogiri::XML(response)
       workspaces = doc.xpath(Workspace.root_xpath).collect{|w| w.text.to_s }
       list Workspace, workspaces, {}, &block
     end
-   
+
     # @param [String] workspace name
     # @return [RGeoServer::Workspace]
     def get_workspace workspace
@@ -66,17 +66,17 @@ module RGeoServer
       name = doc.at_xpath("#{Workspace.member_xpath}/name/text()").to_s
       return Workspace.new self, :name => name
     end
- 
+
     # Assign default workspace
     # @param [String] workspace name
     def set_default_workspace workspace
-       raise TypeError, "Workspace name must be a string" unless workspace.instance_of? String
-       dws = Workspace.new self, :name => 'default'
-       dws.name = workspace # This creates a new workspace if name is new
-       dws.save
-       dws
+      raise TypeError, "Workspace name must be a string" unless workspace.instance_of? String
+      dws = Workspace.new self, :name => 'default'
+      dws.name = workspace # This creates a new workspace if name is new
+      dws.save
+      dws
     end
-    
+
     # @param [String] store
     # @param [String] workspace
     def reassign_workspace store, workspace
@@ -87,13 +87,16 @@ module RGeoServer
 
     # List of available layers
     # @return [Array<RGeoServer::Layer>]
-    def get_layers &block
-      response = self.search :layers => nil 
+    def get_layers options = {}, &block
+      response = self.search :layers => nil
       doc = Nokogiri::XML(response)
-      layers = doc.xpath(Layer.root_xpath).collect{|l| l.text.to_s }
-      list Layer, layers, {}, &block
+      workspace_name = Workspace === options[:workspace] ? options[:workspace].name : options[:workspace]
+      layer_nodes = doc.xpath(Layer.root_xpath).collect{|l| l.text.to_s }
+      layers = list(Layer, layer_nodes, {}, &block)
+      layers = layers.find_all { |layer| layer.workspace.name == workspace_name } if options[:workspace]
+      layers
     end
-   
+
     # @param [String] layer name
     # @return [RGeoServer::Layer]
     def get_layer layer
@@ -103,17 +106,41 @@ module RGeoServer
       return Layer.new self, :name => name
     end
 
+    #= LayerGroups
+
+    # List of available layer groups
+    # @return [Array<RGeoServer::LayerGroup>]
+    def get_layergroups options = {}, &block
+      response = unless options[:workspace]
+                   self.search :layergroups => nil
+                 else
+                   self.search :workspaces => options[:workspace], :layergroups => nil
+                 end
+      doc = Nokogiri::XML(response)
+      layer_groups = doc.xpath(LayerGroup.root_xpath).collect{|l| l.text.to_s }.map(&:strip)
+      list LayerGroup, layer_groups, {workspace: options[:workspace]}, &block
+    end
+
+    # @param [String] layer group name
+    # @return [RGeoServer::LayerGroup]
+    def get_layergroup layergroup
+      response = self.search :layergroups => layergroup
+      doc = Nokogiri::XML(response)
+      name = doc.at_xpath("#{LayerGroup.member_xpath}/name/text()").to_s
+      return LayerGroup.new self, :name => name
+    end
+
     #= Styles (SLD Style Layer Descriptor)
 
     # List of available styles
     # @return [Array<RGeoServer::Style>]
     def get_styles &block
-      response = self.search :styles => nil 
+      response = self.search :styles => nil
       doc = Nokogiri::XML(response)
       styles = doc.xpath(Style.root_xpath).collect{|l| l.text.to_s }
       list Style, styles, {}, &block
     end
-   
+
     # @param [String] style name
     # @return [RGeoServer::Style]
     def get_style style
@@ -125,40 +152,40 @@ module RGeoServer
 
 
     #= Namespaces
- 
+
     # List of available namespaces
     # @return [Array<RGeoServer::Namespace>]
-    def get_namespaces 
+    def get_namespaces
       raise NotImplementedError
-    end 
+    end
 
     # @return [RGeoServer::Namespace]
-    def get_default_namespace 
+    def get_default_namespace
       response = self.search :namespaces => 'default'
       doc = Nokogiri::XML(response)
       name = doc.at_xpath("#{Namespace.member_xpath}/prefix/text()").to_s
       uri = doc.at_xpath("#{Namespace.member_xpath}/uri/text()").to_s
-      return Namespace.new self, :name => name, :uri => uri 
-    end 
+      return Namespace.new self, :name => name, :uri => uri
+    end
 
-    def set_default_namespace id, prefix, uri 
+    def set_default_namespace id, prefix, uri
       raise NotImplementedError
-    end 
+    end
 
     #= Data Stores (Vector datasets)
 
     # List of vector based spatial data
     # @param [String] workspace
     # @return [Array<RGeoServer::DataStore>]
-    def get_data_stores workspace = nil 
-      ws = workspace.nil?? get_workspaces :  [get_workspace(workspace)] 
+    def get_data_stores workspace = nil
+      ws = workspace.nil?? get_workspaces :  [get_workspace(workspace)]
       ds = []
-      ws.each{ |w| ds += w.data_stores if w.data_stores }  
-      ds 
+      ws.each{ |w| ds += w.data_stores if w.data_stores }
+      ds
     end
-     
+
     # @param [String] workspace
-    # @param [String] datastore  
+    # @param [String] datastore
     # @return [RGeoServer::DataStore]
     def get_data_store workspace, datastore
       response = self.search({:workspaces => workspace, :name => datastore})
@@ -166,38 +193,38 @@ module RGeoServer
       name = doc.at_xpath(DataStore.member_xpath)
       return DataStore.new self, workspace, name.text if name
     end
-  
+
     # List of feature types
     # @param [String] workspace
-    # @param [String] datastore 
+    # @param [String] datastore
     # @return [Array<RGeoServer::FeatureType>]
     def get_feature_types workspace, datastore
-      raise NotImplementedError  
+      raise NotImplementedError
     end
 
     # @param [String] workspace
-    # @param [String] datastore  
-    # @param [String] featuretype_id  
+    # @param [String] datastore
+    # @param [String] featuretype_id
     # @return [RGeoServer::FeatureType]
     def get_feature_type workspace, datastore, featuretype_id
-      raise NotImplementedError  
-    end    
+      raise NotImplementedError
+    end
 
 
-    #= Coverages (Raster datasets) 
-    
+    #= Coverages (Raster datasets)
+
     # List of coverage stores
     # @param [String] workspace
     # @return [Array<RGeoServer::CoverageStore>]
     def get_coverage_stores workspace = nil
-      ws = workspace.nil?? get_workspaces :  [get_workspace(workspace)] 
+      ws = workspace.nil?? get_workspaces :  [get_workspace(workspace)]
       cs = []
-      ws.each{ |w| cs += w.coverage_stores if w.coverage_stores }  
-      cs 
+      ws.each{ |w| cs += w.coverage_stores if w.coverage_stores }
+      cs
     end
 
     # @param [String] workspace
-    # @param [String] coveragestore  
+    # @param [String] coveragestore
     # @return [RGeoServer::CoverageStore]
     def get_coverage_store workspace, coveragestore
       cs = CoverageStore.new self, :workspace => workspace, :name => coveragestore
@@ -206,43 +233,43 @@ module RGeoServer
 
     def get_coverage workspace, coverage_store, coverage
       c = Coverage.new self, :workspace => workspace, :coverage_store => coverage_store, :name => coverage
-      return c.new?? nil : c    
+      return c.new?? nil : c
     end
 
     #= WMS Stores (Web Map Services)
 
     # List of WMS stores.
-    # @param [String] workspace  
+    # @param [String] workspace
     # @return [Array<RGeoServer::WmsStore>]
     def get_wms_stores workspace = nil
-      ws = workspace.nil?? get_workspaces :  [get_workspace(workspace)] 
+      ws = workspace.nil?? get_workspaces :  [get_workspace(workspace)]
       cs = []
-      ws.each{ |w| cs += w.wms_stores if w.wms_stores }  
-      cs 
+      ws.each{ |w| cs += w.wms_stores if w.wms_stores }
+      cs
     end
 
     # @param [String] workspace
-    # @param [String] wmsstore  
+    # @param [String] wmsstore
     # @return [RGeoServer::WmsStore]
     def get_wms_store workspace, wmsstore
       response = self.search({:workspaces => workspace, :name => wmsstore})
       doc = Nokogiri::XML(response)
       name = doc.at_xpath(WmsStore.member_xpath)
       return WmsStore.new self, workspace, name.text if name
-    end 
+    end
 
     #= Configuration reloading
     # Reloads the catalog and configuration from disk. This operation is used to reload GeoServer in cases where an external tool has modified the on disk configuration. This operation will also force GeoServer to drop any internal caches and reconnect to all data stores.
     def reload
-      do_url 'reload', :put  
+      do_url 'reload', :put
     end
 
     #= Resource reset
     # Resets all store/raster/schema caches and starts fresh. This operation is used to force GeoServer to drop all caches and stores and reconnect fresh to each of them first time they are needed by a request. This is useful in case the stores themselves cache some information about the data structures they manage that changed in the meantime.
     def reset
       do_url 'reset', :put
-    end  
-  
+    end
+
   end
 
 end

data/lib/rgeoserver/datastore.rb

@@ -3,7 +3,27 @@ module RGeoServer
   # A data store is a source of spatial data that is vector based. It can be a file in the case of a Shapefile, a database in the case of PostGIS, or a server in the case of a remote Web Feature Service.
   class DataStore < ResourceInfo
 
-    OBJ_ATTRIBUTES = {:enabled => "enabled", :catalog => "catalog", :workspace => "workspace", :name => "name", :connection_parameters => "connectionParameters"} 
+    class DataStoreAlreadyExists < StandardError
+      def initialize(name)
+        @name = name
+      end
+
+      def message
+        "The DataStore '#{@name}' already exists and can not be replaced."
+      end
+    end
+
+    class DataTypeNotExpected < StandardError
+      def initialize(data_type)
+        @data_type = data_type
+      end
+
+      def message
+        "The DataStore does not not accept the data type '#{@data_type}'."
+      end
+    end
+
+    OBJ_ATTRIBUTES = {:enabled => "enabled", :catalog => "catalog", :workspace => "workspace", :name => "name", :connection_parameters => "connection_parameters"}
     OBJ_DEFAULT_ATTRIBUTES = {:enabled => 'true', :catalog => nil, :workspace => nil, :name => nil, :connection_parameters => {}}
     define_attribute_methods OBJ_ATTRIBUTES.keys
     update_attribute_accessors OBJ_ATTRIBUTES
@@ -42,13 +62,13 @@ module RGeoServer
       builder = Nokogiri::XML::Builder.new do |xml|
         xml.dataStore {
           xml.name @name
-          xml.enabled @enabled
+          xml.enabled enabled
           xml.connectionParameters {  # this could be empty
-            @connection_parameters.each_pair { |k,v| 
+            connection_parameters.each_pair { |k,v|
               xml.entry(:key => k) {
                 xml.text v
               }
-            } unless @connection_parameters.nil? || @connection_parameters.empty?
+            } unless connection_parameters.nil? || connection_parameters.empty?
           }
         }
       end
@@ -58,7 +78,7 @@ module RGeoServer
     # @param [RGeoServer::Catalog] catalog
     # @param [RGeoServer::Workspace|String] workspace
     # @param [String] name
-    def initialize catalog, options 
+    def initialize catalog, options
       super({})
       _run_initialize_callbacks do
         @catalog = catalog
@@ -70,32 +90,86 @@ module RGeoServer
         else
           raise "Not a valid workspace"
         end
-        
+
         @name = options[:name].strip
         @route = route
-      end        
+      end
     end
 
     def featuretypes &block
       self.class.list FeatureType, @catalog, profile['featureTypes'], {:workspace => @workspace, :data_store => self}, check_remote = true, &block
     end
 
+    # @param [String] file_path
+    # @param [Hash] options { data_type: [:shapefile] }. optional
+    def upload_file file_path, options = {}
+      raise DataStoreAlreadyExists, @name unless new?
+
+      options = options.dup
+
+      data_type = options.delete(:data_type) || :shapefile
+      data_type = data_type.to_sym
+
+      publish = options.delete(:publish) || false
+
+      upload_url_suffix = case data_type
+                          when :shapefile then "#{update_route}/file.shp"
+                          else
+                            raise DataTypeNotExpected, data_type
+                          end
+
+      @catalog.client[upload_url_suffix].put File.read(file_path), :content_type => 'application/zip'
+
+      clear
+      connection_parameters['url'] = connection_parameters['url'].gsub(/.*data/, '').insert(0, 'file:data') #correct to relative path
+      save
+      clear
+
+      if publish
+        ft = RGeoServer::FeatureType.new @catalog, :workspace => @workspace, :data_store => self, :name => @name
+        ft.title = ft.name.capitalize
+        ft.abstract = ft.name.capitalize
+        ft.enabled = true
+
+        bounds = case data_type
+                 when :shapefile
+                   shpInfo = ShapefileInfo.new file_path
+                   shpInfo.bounds
+                 else
+                   raise DataTypeNotExpected, data_type
+                 end
+
+        ft.native_bounds['minx'], ft.native_bounds['miny'], ft.native_bounds['maxx'], ft.native_bounds['maxy'] =
+          bounds.to_a
+        ft.projection_policy = :force
+        ft.save
+
+        layers = catalog.get_layers workspace: @workspace
+        layers.find_all{ |layer| layer.name == ft.name }.each do |layer|
+          layer.enabled = true
+          layer.save
+        end
+      end
+
+      self
+    end
+
     def profile_xml_to_hash profile_xml
       doc = profile_xml_to_ng profile_xml
       h = {
-        "name" => doc.at_xpath('//name').text.strip, 
+        "name" => doc.at_xpath('//name').text.strip,
         "enabled" => doc.at_xpath('//enabled/text()').to_s,
-        "connectionParameters" => doc.xpath('//connectionParameters/entry').inject({}){ |h, e| h.merge(e['key']=> e.text.to_s) } 
+        "connection_parameters" => doc.xpath('//connectionParameters/entry').inject({}){ |h, e| h.merge(e['key']=> e.text.to_s) }
       }
-      doc.xpath('//featureTypes/atom:link/@href', "xmlns:atom"=>"http://www.w3.org/2005/Atom" ).each{ |l| 
+      doc.xpath('//featureTypes/atom:link/@href', "xmlns:atom"=>"http://www.w3.org/2005/Atom" ).each{ |l|
         h["featureTypes"] = begin
-          response = @catalog.do_url l.text
-          Nokogiri::XML(response).xpath('//name/text()').collect{ |a| a.text.strip }
-        rescue RestClient::ResourceNotFound
-          [] 
-        end.freeze
-       }
-      h  
+                              response = @catalog.do_url l.text
+                              Nokogiri::XML(response).xpath('//name/text()').collect{ |a| a.text.strip }
+                            rescue RestClient::ResourceNotFound
+                              []
+                            end.freeze
+      }
+      h
     end
   end
-end 
+end