nofxx-georuby 1.9.0 → 1.9.1

data/Gemfile

@@ -0,0 +1,8 @@
+source :rubygems
+
+group :development do
+  gem "dbf", ">= 1.5.0"
+  gem "rspec", ">= 2.3.0"
+  gem "bundler", ">= 1.0.0"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,29 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.5)
+    dbf (1.5.2)
+      activesupport (~> 3.0.0)
+      fastercsv (= 1.5.3)
+      i18n (~> 0.4.2)
+    diff-lcs (1.1.2)
+    fastercsv (1.5.3)
+    i18n (0.4.2)
+    rcov (0.9.9)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  dbf (>= 1.5.0)
+  rcov
+  rspec (>= 2.3.0)

data/Rakefile

@@ -10,7 +10,6 @@ begin
     gem.email = "georuby@simplitex.com"
     gem.homepage = "http://github.com/nofxx/georuby"
     gem.authors = ["Guilhem Vellut", "Marcos Piccinini", "Marcus Mateus", "Doug Cole"]
-    gem.add_runtime_dependency "json_pure", ">=1.4.6"
     gem.add_development_dependency "rspec", ">= 2.0.0"
     gem.add_development_dependency "dbf", ">= 1.2.9"
   end

data/VERSION

@@ -1 +1 @@
-1.9.0
+1.9.1

data/lib/geo_ruby.rb

@@ -1,5 +1,5 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+# $:.unshift(File.dirname(__FILE__)) #unless
+#  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 require 'geo_ruby/simple_features/helper'
 require 'geo_ruby/simple_features/ewkt_parser'
@@ -15,9 +15,9 @@ require 'geo_ruby/simple_features/multi_polygon'
 require 'geo_ruby/simple_features/geometry_collection'
 require 'geo_ruby/simple_features/envelope'
 require 'geo_ruby/simple_features/geometry_factory'
-require 'geo_ruby/simple_features/georss_parser'
-require 'geo_ruby/simple_features/geojson_parser'
 
-# Include if you need
+# Require if you need
 # require 'geo_ruby/shp4r/shp'
 # require 'geo_ruby/gpx4r/gpx'
+# require 'geo_ruby/geojson'
+# require 'geo_ruby/georss'

data/lib/geo_ruby/geojson.rb

@@ -0,0 +1,129 @@
+# GeoJSON parser based on the v1.0 spec at http://geojson.org/geojson-spec.html
+
+module GeoRuby
+  #Raised when an error in the GeoJSON string is detected
+  class GeojsonFormatError < StandardError
+  end
+
+  # Class added to support geojson 'Feature' objects
+  class GeojsonFeature
+    attr_accessor :geometry, :properties, :id
+
+    def initialize(geometry, properties = {}, id = nil)
+      @geometry = geometry
+      @properties = properties
+      @id = id
+    end
+
+    def ==(other)
+      if (self.class != other.class)
+        false
+      else
+        (self.id == other.id) && (self.geometry == other.geometry) && (self.properties == other.properties)
+      end
+    end
+
+    def to_json(options={})
+      output = {}
+      output[:type] = 'Feature'
+      output[:geometry] = geometry
+      output[:properties] = properties
+      output[:id] = id unless id.nil?
+      output.to_json(options)
+    end
+    alias :as_geojson :to_json
+  end
+
+  # Class added to support geojson 'Feature Collection' objects
+  class GeojsonFeatureCollection
+    attr_accessor :features
+
+    def initialize(features)
+      @features = features
+    end
+
+    def ==(other)
+      if (self.class != other.class) || (features.size != other.features.size)
+        return false
+      else
+        features.each_index do |index|
+          return false if self.features[index] != other.features[index]
+        end
+      end
+      true
+    end
+
+    def to_json(options = {})
+      {:type => 'FeatureCollection',
+        :features => features}.to_json(options)
+    end
+    alias :as_geojson :to_json
+  end
+
+
+  class GeojsonParser
+    attr_reader :geometry
+
+    def parse(geojson, srid=DEFAULT_SRID)
+      @geometry = nil
+      geohash = JSON.parse(geojson)
+      parse_geohash(geohash, srid)
+    end
+
+    private
+
+    def parse_geohash(geohash, srid)
+      srid = srid_from_crs(geohash['crs']) || srid
+      case geohash['type']
+      when 'Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon', 'MultiPolygon', 'GeometryCollection'
+        @geometry = parse_geometry(geohash, srid)
+      when 'Feature'
+        @geometry = parse_geojson_feature(geohash, srid)
+      when 'FeatureCollection'
+        @geometry = parse_geojson_feature_collection(geohash, srid)
+      else
+        GeojsonFormatError.new('Unknown GeoJSON type')
+      end
+    end
+
+    def parse_geometry(geohash, srid)
+      srid = srid_from_crs(geohash['crs']) || srid
+      if geohash['type'] == 'GeometryCollection'
+        parse_geometry_collection(geohash, srid)
+      else
+        klass = GeoRuby::SimpleFeatures.const_get(geohash['type'])
+        klass.from_coordinates(geohash['coordinates'], srid, false, false)
+      end
+    end
+
+    def parse_geometry_collection(geohash, srid)
+      srid = srid_from_crs(geohash['crs']) || srid
+      geometries = geohash['geometries'].map{|g| parse_geometry(g,srid)}
+      GeometryCollection.from_geometries(geometries,srid)
+    end
+
+    def parse_geojson_feature(geohash, srid)
+      srid = srid_from_crs(geohash['crs']) || srid
+      geometry = parse_geometry(geohash['geometry'],srid)
+      GeojsonFeature.new(geometry, geohash['properties'], geohash['id'])
+    end
+
+    def parse_geojson_feature_collection(geohash, srid)
+      srid = srid_from_crs(geohash['crs']) || srid
+      features = []
+      geohash['features'].each do |feature|
+        features << parse_geojson_feature(feature, srid)
+      end
+      GeojsonFeatureCollection.new(features)
+    end
+
+    def srid_from_crs(crs)
+      # We somehow need to map crs to srid, currently only support for EPSG
+      if crs && crs['type'] == 'OGC'
+        urn = crs['properties']['urn'].split(':')
+        return urn.last if urn[4] == 'EPSG'
+      end
+      return nil
+    end
+  end
+end

data/lib/geo_ruby/georss.rb

@@ -0,0 +1,133 @@
+# require 'geo_ruby/simple_features/point'
+# require 'geo_ruby/simple_features/line_string'
+# require 'geo_ruby/simple_features/linear_ring'
+# require 'geo_ruby/simple_features/polygon'
+# require 'geo_ruby/simple_features/multi_point'
+# require 'geo_ruby/simple_features/multi_line_string'
+# require 'geo_ruby/simple_features/multi_polygon'
+# require 'geo_ruby/simple_features/geometry_collection'
+# require 'geo_ruby/simple_features/envelope'
+
+module GeoRuby
+
+  #Raised when an error in the GeoRSS string is detected
+  class GeorssFormatError < StandardError
+  end
+
+  #Contains tags possibly found on GeoRss Simple geometries
+  class GeorssTags < Struct.new(:featuretypetag,:relationshiptag,:elev,:floor,:radius)
+  end
+
+  #Parses GeoRSS strings
+  #You can also use directly the static method Geometry.from_georss
+  class GeorssParser
+    attr_reader :georss_tags, :geometry
+
+    #Parses the georss geometry  passed as argument and notifies the factory of events
+    #The parser assumes
+    def parse(georss,with_tags = false)
+      @geometry = nil
+      @georss_tags = GeorssTags.new
+      parse_geometry(georss,with_tags)
+    end
+
+    private
+    def parse_geometry(georss,with_tags)
+      georss.strip!
+      #check for W3CGeo first
+      if georss =~ /<[^:>]*:lat\s*>([^<]*)</
+        #if valid, it is W3CGeo
+        lat = $1.to_f
+        if georss =~ /<[^:>]*:long\s*>([^<]*)</
+          lon = $1.to_f
+          @geometry = Point.from_x_y(lon,lat)
+        else
+          raise GeorssFormatError.new("Bad W3CGeo GeoRSS format")
+        end
+      elsif georss =~ /^<\s*[^:>]*:where\s*>/
+        #GML format found
+        gml = $'.strip
+        if gml =~ /^<\s*[^:>]*:Point\s*>/
+          #gml point
+          if gml =~ /<\s*[^:>]*:pos\s*>([^<]*)/
+            point = $1.split(" ")
+            #lat comes first
+            @geometry = Point.from_x_y(point[1].to_f,point[0].to_f)
+          else
+            raise GeorssFormatError.new("Bad GML GeoRSS format: Malformed Point")
+          end
+        elsif gml =~ /^<\s*[^:>]*:LineString\s*>/
+          if gml =~ /<\s*[^:>]*:posList\s*>([^<]*)/
+            xy = $1.split(" ")
+            @geometry = LineString.new
+            0.upto(xy.size/2 - 1) { |index| @geometry << Point.from_x_y(xy[index*2 + 1].to_f,xy[index*2].to_f)}
+          else
+            raise GeorssFormatError.new("Bad GML GeoRSS format: Malformed LineString")
+          end
+        elsif gml =~ /^<\s*[^:>]*:Polygon\s*>/
+          if gml =~ /<\s*[^:>]*:posList\s*>([^<]*)/
+            xy = $1.split(" ")
+            @geometry = Polygon.new
+            linear_ring = LinearRing.new
+            @geometry << linear_ring
+            xy = $1.split(" ")
+            0.upto(xy.size/2 - 1) { |index| linear_ring << Point.from_x_y(xy[index*2 + 1].to_f,xy[index*2].to_f)}
+          else
+            raise GeorssFormatError.new("Bad GML GeoRSS format: Malformed Polygon")
+          end
+        elsif gml =~ /^<\s*[^:>]*:Envelope\s*>/
+          if gml =~ /<\s*[^:>]*:lowerCorner\s*>([^<]*)</
+            lc = $1.split(" ").collect { |x| x.to_f}.reverse
+            if gml =~ /<\s*[^:>]*:upperCorner\s*>([^<]*)</
+              uc = $1.split(" ").collect { |x| x.to_f}.reverse
+              @geometry = Envelope.from_coordinates([lc,uc])
+            else
+              raise GeorssFormatError.new("Bad GML GeoRSS format: Malformed Envelope")
+            end
+          else
+            raise GeorssFormatError.new("Bad GML GeoRSS format: Malformed Envelope")
+          end
+        else
+          raise GeorssFormatError.new("Bad GML GeoRSS format: Unknown geometry type")
+        end
+      else
+        #must be simple format
+        if georss =~ /^<\s*[^>:]*:point([^>]*)>(.*)</m
+          tags = $1
+          point = $2.gsub(","," ").split(" ")
+          @geometry = Point.from_x_y(point[1].to_f,point[0].to_f)
+        elsif georss =~ /^<\s*[^>:]*:line([^>]*)>(.*)</m
+          tags = $1
+          @geometry = LineString.new
+          xy = $2.gsub(","," ").split(" ")
+          0.upto(xy.size/2 - 1) { |index| @geometry << Point.from_x_y(xy[index*2 + 1].to_f,xy[index*2].to_f)}
+        elsif georss =~ /^<\s*[^>:]*:polygon([^>]*)>(.*)</m
+          tags = $1
+          @geometry = Polygon.new
+          linear_ring = LinearRing.new
+          @geometry << linear_ring
+          xy = $2.gsub(","," ").split(" ")
+          0.upto(xy.size/2 - 1) { |index| linear_ring << Point.from_x_y(xy[index*2 + 1].to_f,xy[index*2].to_f)}
+        elsif georss =~ /^<\s*[^>:]*:box([^>]*)>(.*)</m
+          tags = $1
+          corners = []
+          xy = $2.gsub(","," ").split(" ")
+          0.upto(xy.size/2 - 1) {|index| corners << Point.from_x_y(xy[index*2 + 1].to_f,xy[index*2].to_f)}
+          @geometry = Envelope.from_points(corners)
+        else
+          raise GeorssFormatError.new("Bad Simple GeoRSS format: Unknown geometry type")
+        end
+
+        #geometry found: parse tags
+        return unless with_tags
+
+        @georss_tags.featuretypetag = $1 if tags =~ /featuretypetag=['"]([^"']*)['"]/
+        @georss_tags.relationshiptag = $1 if tags =~ /relationshiptag=['"]([^'"]*)['"]/
+        @georss_tags.elev = $1.to_f if tags =~ /elev=['"]([^'"]*)['"]/
+        @georss_tags.floor = $1.to_i if tags =~ /floor=['"]([^'"]*)['"]/
+        @georss_tags.radius = $1.to_f if tags =~ /radius=['"]([^'"]*)['"]/
+
+      end
+    end
+  end
+end

data/lib/geo_ruby/simple_features/ewkb_parser.rb

@@ -32,36 +32,37 @@ module GeoRuby
       #Parses the ewkb string passed as argument and notifies the factory of events
       def parse(ewkb)
         @factory.reset
-        @unpack_structure=UnpackStructure::new(ewkb)
         @with_z = false
         @with_m = false
+        @unpack_structure = UnpackStructure::new(ewkb)
         parse_geometry
         @unpack_structure.done
-        @srid=nil
+        @srid = nil
       end
 
       private
+
       def parse_geometry
-        @unpack_structure.endianness=@unpack_structure.read_byte
-        @geometry_type = @unpack_structure.read_uint
+        @unpack_structure.endianness = @unpack_structure.read_byte
+        geometry_type = @unpack_structure.read_uint
 
-        if (@geometry_type & Z_MASK) != 0
-          @with_z=true
-          @geometry_type = @geometry_type & ~Z_MASK
+        if (geometry_type & Z_MASK) != 0
+          @with_z = true
+          geometry_type = geometry_type & ~Z_MASK
         end
-        if (@geometry_type & M_MASK) != 0
-          @with_m=true
-          @geometry_type = @geometry_type & ~M_MASK
+        if (geometry_type & M_MASK) != 0
+          @with_m = true
+          geometry_type = geometry_type & ~M_MASK
         end
-        if (@geometry_type & SRID_MASK) != 0
+        if (geometry_type & SRID_MASK) != 0
           @srid = @unpack_structure.read_uint
-          @geometry_type = @geometry_type & ~SRID_MASK
+          geometry_type = geometry_type & ~SRID_MASK
         else
           #to manage multi geometries : the srid is not present in sub_geometries, therefore we take the srid of the parent ; if it is the root, we take the default srid
-          @srid= @srid || DEFAULT_SRID
+          @srid ||= DEFAULT_SRID
         end
 
-        case @geometry_type
+        case geometry_type
         when 1
           parse_point
         when 2
@@ -129,8 +130,7 @@ module GeoRuby
 
       def parse_point
         @factory.begin_geometry(Point,@srid)
-        x = @unpack_structure.read_double
-        y = @unpack_structure.read_double
+        x, y = *@unpack_structure.read_point
         if ! (@with_z or @with_m) #most common case probably
           @factory.add_point_x_y(x,y)
         elsif @with_m and @with_z
@@ -151,56 +151,59 @@ module GeoRuby
 
     #Parses HexEWKB strings. In reality, it just transforms the HexEWKB string into the equivalent EWKB string and lets the EWKBParser do the actual parsing.
     class HexEWKBParser < EWKBParser
-      def initialize(factory)
-        super(factory)
-      end
+
       #parses an HexEWKB string
       def parse(hexewkb)
         super(decode_hex(hexewkb))
       end
+
       #transforms a HexEWKB string into an EWKB string
       def decode_hex(hexewkb)
         [hexewkb].pack("H*")
       end
     end
 
-    class HexEWKBParser < EWKBParser
-     #transforms a HexEWKB string into an EWKB string
-     # Patched for speedup
-
-   end
-
     class UnpackStructure #:nodoc:
-      NDR=1
-      XDR=0
+      NDR = 1
+      XDR = 0
+
       def initialize(ewkb)
-        @position=0
-        @ewkb=ewkb
+        @position = 0
+        @ewkb = ewkb
       end
+
       def done
         raise EWKBFormatError::new("Trailing data") if @position != @ewkb.length
       end
+
+      def read_point
+        i = @position
+        @position += 16
+        raise EWKBFormatError::new("Truncated data") if @ewkb.length < @position
+        @ewkb.unpack("@#{i}#@double_mark#@double_mark@*")
+      end
+
       def read_double
-        i=@position
+        i = @position
         @position += 8
-        packed_double = @ewkb[i...@position]
-        raise EWKBFormatError::new("Truncated data") if packed_double.nil? or packed_double.length < 8
-        packed_double.unpack(@double_mark)[0]
+        raise EWKBFormatError::new("Truncated data") if @ewkb.length < @position
+        @ewkb.unpack("@#{i}#@double_mark@*").first
       end
+
       def read_uint
-        i=@position
+        i = @position
         @position += 4
-        packed_uint = @ewkb[i...@position]
-        raise EWKBFormatError::new("Truncated data") if packed_uint.nil? or packed_uint.length < 4
-        packed_uint.unpack(@uint_mark)[0]
+        raise EWKBFormatError::new("Truncated data") if @ewkb.length < @position
+        @ewkb.unpack("@#{i}#@uint_mark@*").first
       end
+
       def read_byte
         i = @position
         @position += 1
-        packed_byte = @ewkb[i...@position]
-        raise EWKBFormatError::new("Truncated data") if packed_byte.nil? or packed_byte.length < 1
-        packed_byte.unpack("C")[0]
+        raise EWKBFormatError::new("Truncated data") if @ewkb.length < @position
+        @ewkb.unpack("@#{i}C@*").first
       end
+
       def endianness=(byte_order)
         if(byte_order == NDR)
           @uint_mark="V"