arcserver.rb 0.1.3 → 0.1.4

data/README.rdoc

@@ -1,7 +1,57 @@
 = arcserver.rb
 
-Description goes here.
+arcserver.rb is a unified interface for interacting with ESRI Arcserver (9.3+)
+SOAP and REST APIs from Ruby.  Extra utility methods are also provided for
+generating legend images.
+
+== Installation
+
+  [sudo] gem install arcserver.rb
+
+<em>Optional: (some of the utility methods require RMagick)</em>
+  [sudo] gem install rmagick
+
+== Quick Example
+
+  require 'arcserver'
+
+  # connect to a map server instance using either its REST or SOAP url
+  map_server = ArcServer::MapServer.new('http://sampleserver1.arcgisonline.com/ArcGIS/services/Portland/ESRI_LandBase_WebMercator/MapServer')
+
+  # get the default map name using the SOAP API
+  puts map_server.get_default_map_name
+
+  # get legend information using the SOAP API
+  puts map_server.get_legend_info
+
+  # export an image using the REST
+  puts map_server.export
+
+== Contributors
+
+The following people have contributed their time and effort to arcserver.rb:
+
+* Colin Casey
+* Glenn Goodrich
+
+== Contribute
+
+If you'd like to hack on arcserver.rb, start by forking my repo on GitHub:
+
+  http://github.com/colincasey/arcserver.rb
+
+To get all of the dependencies, install the gem first. The best way to get your changes merged back into core is as follows:
+
+1. Clone your fork
+2. Create a thoughtfully named topic branch to contain your change
+3. Hack away
+4. Add tests and make sure everything still passes by running rake
+5. If you are adding new functionality, document it in the README
+6. Do not change the version number, I will do that on my end
+7. If necessary, rebase your commits into logical chunks, without errors
+8. Push the branch up to GitHub
+9. Send me (colincasey[http://github.com/colincasey]) a pull request for your branch
 
 == Copyright
 
-Copyright (c) 2009 Colin Casey. See LICENSE for details.
+Copyright (c) 2010 Colin Casey. See LICENSE for details.

data/Rakefile

@@ -33,6 +33,16 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new do |t|
+    t.files   = ['lib/**/*.rb']
+  end
+rescue LoadError
+
+end
+
 desc "Build arcserver.rb gem"
 task :build do
   system "gem build arcserver.rb.gemspec"

data/lib/arcserver/map_server.rb

@@ -25,14 +25,14 @@ module ArcServer
     end
 
     # Utility method for generating a legend image
-    # (requires optional dependency, RMagick [>= 2.13.1], to be installed)
+    # (requires optional dependency, RMagick [>= 2.12.0], to be installed)
     #
     # @return [Magick::Image] the legend as an RMagick Image object
     def get_legend_image
        begin
          require 'RMagick' unless Object.const_defined?("Magick")
        rescue LoadError
-         raise ArcServerError, "#{self.class}#get_legend_image needs an optional dependency 'RMagick [>= 2.13.1]' to be installed - try `gem install rmagick`"
+         raise ArcServerError, "#{self.class}#get_legend_image needs an optional dependency 'RMagick [>= 2.12.0]' to be installed - try `gem install rmagick`"
        end
        Util::LegendImage.new(self).get_image
     end

data/lib/arcserver/rest/map_server.rb

@@ -2,23 +2,228 @@
 
 module ArcServer
   module REST
+    # Map services offer access to map and layer content. Map services can either
+    # be cached or dynamic. A map service that fulfills requests with pre-created
+    # tiles from a cache instead of dynamically rendering part of the map is called
+    # a cached map service. A dynamic map service requires the server to render
+    # the map each time a request comes in. Map services using a tile cache can
+    # significantly improve performance while delivering maps, while dynamic map
+    # services offer more flexibility. Map services should always be published as
+    # pooled services.
+    #
+    # The REST API map service resource represents a map service. This resource
+    # works only with the default data frame of your published map document. This
+    # resource provides basic information about the map, including the layers that
+    # it contains, whether the map is cached or not, its spatial reference, initial
+    # and full extents, map units, and copyright text. It also provides some metadata
+    # associated with the service such as its service description, its author, and
+    # keywords. If the map is cached, then additional information about its tiling
+    # scheme such as the origin of the cached tiles, the levels of detail, and tile
+    # size is included. Note that multi-layer caches are only accessible in REST
+    # via export, and these requests are treated as a dynamic map service. Tile
+    # access is not supported in REST for multi-layer caches.
+    #
+    # The map service resource supports several operations:
+    #
+    # * Export map - Used to export a map image from a dynamic map service. The
+    #   resulting map can be used for display and be in a different projection from
+    #   the original data source. When generating a map image, map services are
+    #   not able to change feature rendering for an existing layer, add a dynamic
+    #   layer, or change the layer draw order.
+    #
+    # * Identify - Returns information about features in one or more layers based
+    #   on where a user clicks on the map.
+    #
+    # * Find - Returns information about features in one or more fields in one or
+    #   more layers based on a key word.
+    #
+    # * Generate KML - Generates a KML document wrapped in a kmz file. The document
+    #   contains a network link to the KML service endpoint with specified properties
+    #   and parameters. This operation is valid on services that have not been restricted
+    #   by using a token service.
+    #
+    # * Query on a Layer - Returns a subset of features in a layer based on query
+    #   criteria.
+    #
+    # * Map services do not expose editing capabilities. They provide read-only
+    #   access to feature and attribute content.
     class MapServer
+      # The REST url of a map service 
       attr_reader :url
 
+      # @param [String] url the REST url of a map service
+      # @example
+      #   ArcServer::MapServer.new("http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/Specialty/ESRI_StateCityHighway_USA/MapServer")
       def initialize(url)
         @url = url
       end
 
-      def export(opts = {})
-        query = {
-          :bbox        => opts[:bbox],
-          :f           => opts[:f]           || :image,
-          :format      => opts[:format]      || :png24,
-          :transparent => opts[:transparent] || true,
-          :size        => opts[:size],
-          :dpi         => opts[:dpi]
+      # The export operation is performed on a map service resource. The result
+      # of this operation is a map image resource. This resource provides information
+      # about the exported map image such as its URL, its width and height, extent
+      # and scale.
+      #
+      # Apart from the usual response formats of html and json, users can also
+      # request a format called image while performing this operation. When users
+      # perform an export with the format of image, the server responds by directly
+      # streaming the image bytes to the client. One must note that with this
+      # approach you don't get any information associated with the exported map
+      # other than the actual image.
+      #
+      # Note that the extent displayed in the exported map image may not exactly
+      # match the extent sent in the bbox parameter when the aspect ratio of the
+      # image size does not match the aspect ratio of the bbox.  The aspect ratio
+      # is the height divided by the width.  In these cases the extent is re-sized
+      # to prevent map images from appearing stretched.  The exported map’s extent
+      # is sent along with the json and html responses and may be used in client
+      # side calculations. So it is important that the client-side code update its
+      # extent based on the response.
+      # 
+      # @param [Hash] params the query parameters to pass to the export operation
+      # 
+      # @option params [String, Symbol] :f (:image) The response format. The default response
+      #   format is html. If the format is image, the image bytes are directly streamed
+      #   to the client.
+      #
+      #     # Values: html | json | image | kmz | pjson (pretty json)
+      #     # Examples:
+      #     :f => :json
+      #     :f => 'kmz'
+      #
+      # @option params [required, String, Array] :bbox The extent (bounding box) of
+      #   the exported image. Unless the bboxSR parameter has been specified, the
+      #   bbox is assumed to be in the spatial reference of the map.
+      #
+      #     # Syntax: <xmin>, <ymin>, <xmax>, <ymax>
+      #     # Examples:
+      #     :bbox => "-104,35.6,-94.32,41"
+      #     :bbox => [-104,35.6,-94.32,41]
+      #
+      #     # Note: The bboxcoordinates should always use a period as the decimal separator
+      #     # even in countries where traditionally a comma is used.
+      #
+      # @option params [String, Array] :size ([400, 400]) The size (width * height) of the exported
+      #   image in pixels. If the size is not specified, an image with a default
+      #   size of 400 * 400 will be exported.
+      #
+      #     # Syntax: <width>, <height>
+      #     # Examples:
+      #     :size => "600,550"
+      #     :size => [600,550]
+      #
+      # @option params [Integer] :dpi (96) The device resolution of the exported
+      #   image (dots per inch).
+      #
+      #     # Example:
+      #     :dpi => 300
+      #
+      # @option params [Integer] :imageSR	The well-known ID of the spatial reference
+      #   of the exported image. If the imageSR is not specified, the image will
+      #   be exported in the spatial reference of the map.
+      #
+      #     # Example:
+      #     :imageSR => 4326
+      #
+      # @option params [Integer] :bboxSR The well-known ID of the spatial reference
+      #   of the bbox. If the bboxSR is not specified, the bbox is assumed to be
+      #   in the spatial reference of the map.
+      #
+      #     # Example:
+      #     :bboxSR => 4326
+      #
+      # @option params [String, Symbol] :format (:png) The format of the exported
+      #   image.
+      #
+      #     # Values: png | png8 | png24 | jpg | pdf | bmp | gif | svg | png32
+      #     # Examples:
+      #     :format => :png32
+      #     :format => 'jpg'
+      #
+      #     # Note: Support for the png32 format was added at 9.3.1. This format is only
+      #     # available for map services whose supportedImageFormatTypes property includes PNG32
+      #
+      # @option params [String] :layerDefs	Allows you to filter the features of
+      #   individual layers in the exported map by specifying definition expressions
+      #   for those layers.
+      #
+      #     # Syntax: layerId1:layerDef1;layerId2:layerDef2
+      #     # (where layerId1, layerId2 are the layer ids returned by the map service resource)
+      #     # Example:
+      #     :layersDefs => "0:POP2000 > 1000000;5:AREA > 100000"
+      #     :layersDefs => { 0 => "POP2000 > 1000000", 1 => "AREA > 100000" }
+      #
+      # @option params [String, Hash<Symbol, Array>] layers	Determines which layers appear on the exported
+      #   map. There are four ways to specify which layers are shown:
+      #
+      #   * show: Only the layers specified in this list will be exported.
+      #   * hide: All layers except those specified in this list will be exported.
+      #   * include: In addition to the layers exported by default, the layers specified in this list will be exported.
+      #   * exclude: The layers exported by default excluding those specified in this list will be exported.
+      #
+      #       # Syntax: [show | hide | include | exclude]:layerId1,layerId2
+      #       # where layerId1, layerId2are the layer ids returned by the map service resource      
+      #       # Examples:
+      #       :layers => "show:2,4,7"
+      #       :layers => { :show => [2,4,7] }
+      #
+      # @option params [true, false] transparent (false)	If true, the image will be exported
+      #   with the background color of the map set as its transparent color. The default
+      #   is false. Only the png and gif formats support transparency.  Internet
+      #   Explorer 6 does not display transparency correctly for png24 image formats.
+      #
+      # @example
+      #   # create a map service
+      #   map_service = MapServer.new("http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/Specialty/ESRI_StateCityHighway_USA/MapServer")
+      #
+      #   # Export a map
+      #   map_service.export(:bbox => "-127.8,15.4,-63.5,60.5")
+      #
+      #   # Export a map and change imageSR to 102004 (USA_Contiguous_Lambert_Conformal_Conic projection)
+      #   map_service.export(:bbox => "-127.8,15.4,-63.5,60.5", :imageSR => 102004, :f => "html")
+      #
+      #   # Export a map, change imageSR to 102004 (USA_Contiguous_Lambert_Conformal_Conic projection),
+      #   # set image size to a width and height of 800x600, format to gif, and transparent to true.
+      #   map_service.export(:bbox => "-115.8,30.4,-85.5,50.5", :size => "800,600", :imageSR => 102004, :format => "gif", :transparent => false, :f => "html")
+      #
+      #   # Export the same map as above but change the output format to pretty json (f=pjson).
+      #   map_service.export(:bbox => "-115.8,30.4,-85.5,50.5", :size => "800,600", :imageSR => 102004, :format => "gif", :transparent => false, :f => "pjson")
+      #
+      # @example
+      #   JSON Response Syntax:
+      #   {
+      #     "href" : "<href>",
+      #     "width" : <width>,
+      #     "height" : <height>,
+      #     "extent" : {<envelope>},
+      #     "scale" : <scale>
+      #   }
+      #
+      #   JSON Response Example:
+      #   {
+      #     "href" : "http://atlantic/arcgisoutput/_ags_map42ef5eae899942a9b564138e184a55c9.png",
+      #     "width" : 400,
+      #     "height" : 400,
+      #     "extent" : {
+      #       "xmin" : -109.55,
+      #       "ymin" : 25.76,
+      #       "xmax" : -86.39,
+      #       "ymax" : 49.94,
+      #       "spatialReference" : { "wkid" : 4326 }
+      #     },
+      #     "scale" : 2.53E7
+      #   }
+      #
+      # @return [HTTParty::Response] the HTTP response
+      def export(params = {})
+        params = {
+          :bbox        => params[:bbox],
+          :f           => params[:f]           || :image,
+          :format      => params[:format]      || :png24,
+          :transparent => params[:transparent] || true,
+          :size        => params[:size],
+          :dpi         => params[:dpi]
         }
-        HTTParty.get("#{url}/export", :query => query)
+        HTTParty.get("#{url}/export", :query => params)
       end
     end
   end

data/lib/arcserver/soap/map_server.rb

@@ -2,7 +2,147 @@
 
 module ArcServer
   module SOAP
+    # Map services offer access to map and attribute content. Map services can either be cached
+    # or dynamic. A map service that fulfills requests with pre-created tiles from a cache instead
+    # of dynamically rendering part of the map is called a cached map service. A dynamic map
+    # service requires the server to render the map each time a request comes in. Map services
+    # using a tile cache can significantly improve performance while delivering maps, while dynamic
+    # map services offer more flexibility.
+    #
+    # Map services offer the following capabilities:
+    # * Generate map images for a specified geographic area
+    # * Change the description of the map
+    # * Control the output map image
+    # * Get map legend information
+    # * Query map features using attributes or spatial filters
+    # * Get information regarding the cache
+    # * Get a scale bar
+    #
+    # WSDL syntax:
+    #   http://<Web Server Hostname>/<ArcGIS Instance>/services/<ServiceName>/MapServer?wsdl
+    #
+    # =Working with map services
+    #
+    # ==Get information about the map and its layers
+    #
+    # To access information about a map and its layers use GetServerInfo. GetServerInfo returns MapServerInfo
+    # and MapLayerInfo. MapServerInfo contains read-only information describing the default state of a map
+    # service, such as the name of the map, the background color or the spatial extent of the map. Read-only
+    # layer properties, such as the layer’s name, the layer’s attributes and whether or not the layer has
+    # labels associated with it, can be retrieved from MapLayerInfo.
+    #
+    # If you wish to make changes to the map or to map layers you will need to use MapDescription or
+    # LayerDescription. Use MapDescription to access map settings that can be changed such as geographic
+    # extent and spatial reference. MapDescription provides access to information on individual layers within
+    # the map. LayerDescription provides the ability to change the visibility of a layer, to toggle the visibility
+    # of existing labels belonging to the layer and to assign a expression in order to display a specified
+    # subset of features.
+    #
+    # == Exporting a map image
+    #
+    # To export a map image from a dynamic map service use ExportMapImage. An ImageDescription contains an ImageType
+    # and an ImageDisplay. Specifying the image format, such as JPG or PNG, is done using ImageType. Use ImageDisplay to
+    # specify the height and width of the image. You can also specify a transparent color using ImageDisplay. The server
+    # will restrict the maximum size an image can be. Use GetServiceConfigurationInfo to view the maximum height and width.
+    # GetServiceConfigurationInfo contains a set of name-value pairs for properties set for the MapServer Service
+    # Configuration Restrictions.
+    #
+    # ==Information about legend elements
+    #
+    # You can retrieve legend elements including the symbol image, labels, descriptions and headings. A common use would
+    # be to populate a table of contents. To retrieve legend information, use GetLegendInfo and MapServerLegendInfo
+    # to retrieve specific information for a particular layer.
+    #
+    # ==Querying the map
+    #
+    # Map services offer a number of methods to perform query operations on the map. These include:
+    # * Find
+    # * Identify
+    # * QueryHyperlinks
+    # * QueryFeatureCount
+    # * QueryFeatureData
+    # * QueryFeatureIDs
+    # * QueryFeatureCount2
+    # * QueryFeatureData2
+    # * QueryFeatureIDs2
+    #
+    # Find returns an array of MapServerFindResults based on a search string. Use MapServerFindResult to access properties
+    # of found features, such as the found value, the layer ID, the field name, the geometry of the found feature and a
+    # set of name-value pairs for the field names and values of the found features.
+    #
+    # Identify returns an array of MapServerIdentifyResults based on search shape. Use MapServerIdentifyResult to access
+    # properties of identified features. These include: layer ID, name, a set of name-value pairs for the field names and values
+    # of the identified object, and the geometry of the identified.
+    #
+    # QueryFeatureCount and QueryFeatureCount2 both return the number of features that match a query. The difference between
+    # the two operations is QueryFeatureCount requires a LayerID as one of the parameters, while QueryFeatureCount2 requires
+    # a LayerDescription instead. By passing in a LayerDescription you can query against a specific sub set of the layer by
+    # apply a definition expression.
+    #
+    # QueryFeatureID and QueryFeatureID2 both return an FIDSet. This is the set of feature IDs that match the query criteria.
+    # The difference between the two operations is QueryFeatureCount requires a LayerID as one of the parameters, while
+    # QueryFeatureCount2 requires a LayerDescription instead. By passing in a LayerDescription you can query against a specific
+    # subset of the layer by apply a definition expression.
+    #
+    # QueryFeatureData and QueryFeatureData2 differ not only in the required parameters, but also in  what is returned.
+    # QueryFeatureData returns a RecordSet base on a specific query and includes a LayerID in the method parameters.
+    # QueryFeatureData2 returns a QueryResult. A QueryResult includes the URL of the generated query result in the requested
+    # format. The result format can be specified by using QueryResultOptions.  The query result can be formatted into a RecordSet
+    # or KMZ format (either as a URL to the kmz file or a Mime object). Another property includes GeoTransformation. This is
+    # used to specify any needed geographic transformation on the results.
+    #
+    # The server will restrict the maximum number of records that can be sent. Use GetServiceConfigurationInfo the maximum records
+    # that can be returned in a query for this particular map service. GetServiceConfigurationInfo contains a set of name-value
+    # pairs for properties set for the MapServer Service Configuration Restrictions. This restriction does not affect
+    # QueryFeatureCount, QueryFeatureIds, QueryFeatureCount2 or QueryFeatureIds2.
+    #
+    # =Working with cached vs. dynamic map services
+    #
+    # ArcGIS Server map services provide access to two types of visible map content: dynamic and cached.  Dynamic maps
+    # are generated on-the-fly per a user request.  Layer visibility, graphics, and other variables can be modified before
+    # the dynamic map is generated.  Unfortunately, as the amount of content and complexity in the map increases, so
+    # does the amount of time it takes to generate the map.  Alternatively, cached maps consist of pre-generated map
+    # tiles available for immediate access.  Since the cost of generating the maps has already been paid, the performance
+    # penalty associated with map generation is not a factor.   Working with a map cache requires knowledge of cache
+    # properties, such a location and structure, so that you are able to retrieve the appropriate cached image.   In
+    # general, a map cache is stored in a nested set of directories which contain image tiles for map extents at specific
+    # scale levels, or levels of detail.   The author of the map service determines these levels.  The cached tiles are
+    # usually accessible via a public virtual directory or an ArcGIS Server map service tile handler.
+    #
+    # ==Information about a map cache
+    #
+    # Use IsFixedScaleMap to determine if a map service is cached. The term fixed scale map service and cached map service are
+    # used synonymously.  GetCacheDescriptionInfo returns information on a cached map service in one call including its
+    # cache type, its tiling scheme (TileCacheInfo), image information (TileImageInfo) and control information (TileControlInfo).
+    #
+    # TileCacheInfo contains information on the tiling scheme for the cache. The tiling scheme includes the tiling origin,
+    # spatial reference, tile size in pixels and information on the Levels of Detail (LOD) at which the service is cached.
+    # LODInfos enumerate a LODInfo object which describes a scale and resolution. Using the tiling scheme information in
+    # TileCacheInfo the client can calculate the tiles that cover any rectangular extent in map space and then retrieve
+    # tiles either directly from  the virtual directory, or from the tile handler or by making GetMapTile or GetLayerTile
+    # requests against the map service.
+    #
+    # GetMapTile gets the specified tile from a map service that has a single fused cache. GetLayerTile gets the specified
+    # tile for a defined layer from a map service that has a multi-layer cache.
+    #
+    # GetTileImageInfo returns information describing the image format for the cached tiles. TileImageInfo has two main
+    # properties Format and Compression quality. Format can have values (PNG8, PNG24, PNG32 and JPEG). If the selected format
+    # is JPEG, then the compression quality can have a value from 0 to 100. The value of format must be used in constructing
+    # the URL to the tile.
+    #
+    # GetCacheControlInfo returns cache control information that allows clients to discover information such as if client
+    # caching is allowed.
+    #
+    # =Limitations
+    #
+    # When generating a map image, map services are not able to perform the following tasks:
+    # * Change feature render for an existing layer.
+    # * Add a dynamic layer
+    # * Change layer draw order
+    #
+    # Map services do not expose editing capabilities.  They merely provide read-only access to feature and attribute content.
     class MapServer < Handsoap::Service
+      protected
       on_create_document do |doc|
         doc.alias "env", "http://schemas.xmlsoap.org/soap/envelope/"
         doc.alias "ns",  "http://www.esri.com/schemas/ArcGIS/9.3"
@@ -12,16 +152,48 @@ module ArcServer
         self.class.endpoint(:uri => @soap_url, :version => 1)
       end
 
+      public
       def initialize(soap_url, protocol_version=2)
         @soap_url = soap_url
       end
 
+      # Get the name of the active map (data frame) in a map service.
+      # @return [String] A string representing name of the active map in the map service.
       def get_default_map_name
         response = invoke("ns:GetDefaultMapName")
         node = response.document.xpath('//tns:GetDefaultMapNameResponse/Result', ns).first
         parse_default_map_name_result(node)
       end
 
+      # Returns legend information, such as layer name, group heading, classification labels and symbol swatches,
+      # for layers in a map.
+      #
+      # A map service does not have the ability to generate a single legend image will all legend content.  Instead,
+      # the GetLegendInfo() method provides access to legend content which can be used to construct a single consolidated
+      # legend.
+      #
+      # Each MapServerLegendInfo object contains one or more MapServerLegendGroup objects.  Each MapServerLegendGroup object
+      # contains one or more MapServerLegendClass objects.  The relationship between value objects and legend content is
+      # illustrated in the following diagram.  Note that each MapServerLegendClass contains a classification label and symbol
+      # swatch.
+      #
+      # @param [Hash] args the arguments to send in the SOAP request
+      #
+      # @option args [String] :map_name (get_default_map_name()) the name of the map (data frame) that will
+      #   be used to generate legend info
+      #
+      # @option args [Array<Integer>] :layer_ids (nil) An array of layer ids for which legend information will
+      #   be returned.  If empty or null, all layers will be included.
+      #
+      # @option args [LegendPatch] :legend_patch (nil) A MapServerLegendPatch used to define symbol swatch properties
+      #   for legend classifications.  If empty or null, the default patch properties defined in the map will be used.
+      #
+      # @option args [String] :image_type ("esriImageReturnMimeData") An ImageType defines the image type and method for
+      #   returning the image content for the symbol swatches. Supported image types are 'bmp', 'jpg', 'tif', 'png'/'png8',
+      #   'png24', 'emf', 'ps', 'pdf', 'ai', 'gif', and 'svg'/'svgz'.  Image content can be returned as a URL or as a
+      #   MIME data stream.
+      #
+      # @return [Hash] the SOAP response decoded into a Hash
       def get_legend_info(args = {})
         image_return_type = args[:image_return_url] ? "esriImageReturnURL" : "esriImageReturnMimeData"
         response = invoke("ns:GetLegendInfo") do |message|
@@ -37,7 +209,7 @@ module ArcServer
 
       private
       def ns
-        { 'tns', 'http://www.esri.com/schemas/ArcGIS/9.3' }
+        { 'tns' => 'http://www.esri.com/schemas/ArcGIS/9.3' }
       end
 
       # helpers

data/lib/arcserver/version.rb

@@ -2,6 +2,6 @@
 module ArcServer
   MAJOR = 0
   MINOR = 1
-  PATCH = 3
+  PATCH = 4
   VERSION = [MAJOR, MINOR, PATCH].join('.')
 end

data/test/functional/soap/map_server_test.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-require File.dirname(__FILE__) + '/../../test_helper'
+require File.expand_path("../../../test_helper", __FILE__)
 require 'yaml'
 
 #ArcServer::SOAP::MapServer.logger = $stdout

data/test/unit/map_server_test.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-require File.dirname(__FILE__) + '/../test_helper'
+require File.expand_path("../../test_helper", __FILE__)
 
 class ArcServer::MapServerTest < Test::Unit::TestCase
   should "raise an error if the required url is not a map server url" do

data/test/unit/url_helper_test.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-require File.dirname(__FILE__) + '/../test_helper'
+require File.expand_path("../../test_helper", __FILE__)
 
 class ArcServer::UrlHelperTest < Test::Unit::TestCase
   include ArcServer::UrlHelper

data/test/unit/util/legend_image_test.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-require File.dirname(__FILE__) + '/../../test_helper'
+require File.expand_path("../../../test_helper", __FILE__)
 require 'RMagick'
 
 class ArcServer::Util::LegendImageTest < Test::Unit::TestCase

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 3
-  version: 0.1.3
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - Colin Casey
@@ -117,12 +117,12 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 2
-        - 13
-        - 1
-        version: 2.13.1
+        - 12
+        - 0
+        version: 2.12.0
   type: :development
   version_requirements: *id007
-description: arcserver.rb is a utility for accessing ESRI ArcServer REST and SOAP APIs from a unified interface
+description: A library for accessing ESRI ArcServer REST and SOAP APIs from a unified interface
 email: 
 - casey.colin@gmail.com
 executables: []
@@ -179,7 +179,7 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Library for accessing ESRI ArcServer REST and SOAP APIs.
+summary: A library for accessing ESRI ArcServer REST and SOAP APIs from a unified interface
 test_files: 
 - test/functional/soap/map_server_test.rb
 - test/test_helper.rb